From 181207a57cd625a128911480a5a4891c5b02e34b Mon Sep 17 00:00:00 2001 From: Daniel Sanche Date: Thu, 12 Nov 2026 20:36:39 -0700 Subject: [PATCH 1/4] fix: avoid build log payloads when no handlers are attached --- .../%sub/services/%service/_shared_macros.j2 | 18 +++- .../%sub/services/%service/async_client.py.j2 | 6 +- .../%sub/services/%service/client.py.j2 | 6 +- .../services/%service/transports/rest.py.j2 | 6 +- .../%service/transports/rest_asyncio.py.j2 | 6 +- .../%name_%version/%sub/test_%service.py.j2 | 91 +++++++++++++++++++ 6 files changed, 126 insertions(+), 7 deletions(-) diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 index 571de46f7a48..b9ed78138ce7 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 @@ -226,7 +226,11 @@ def _get_http_options(): rest_numeric_enums={{ rest_numeric_enums }}, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -351,7 +355,11 @@ return {{ client_output_ident }}( {% macro unary_request_interceptor_common(service) %} - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): @@ -634,7 +642,11 @@ class {{ name|make_private }}(_Base{{ service.name }}RestTransport._Base{{name}} resp = {{ sig.response_type }}() resp = json_format.Parse(content, resp) resp = {{ await_prefix }}self._interceptor.post_{{ name|snake_case }}(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 index 8d96ab289388..c7970699d4f7 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 @@ -264,7 +264,11 @@ class {{ service.async_client_name }}: ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `{{ service.meta.address.proto_package_versioned }}.{{ service.async_client_name }}`.", extra = { diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 index 85c6855ebce1..0ff0fc4afc73 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 @@ -567,7 +567,11 @@ class {{ service.client_name }}(metaclass={{ service.client_name }}Meta): self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `{{ service.meta.address.proto_package_versioned }}.{{ service.client_name }}`.", extra = { diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 index 4544b1ad7b1d..0d2f248976d9 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 @@ -303,7 +303,11 @@ class {{service.name}}RestTransport(_Base{{ service.name }}RestTransport): resp = self._interceptor.post_{{ method.name|snake_case }}(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_{{ method.name|snake_case }}_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2389): #} {# Depending how we want to log (a) receiving a streaming response vs (b) exposing the next streamed item to the user, we could possibly want to log something here #} {# (a) should always happen in api-core #} diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 index abad21c3caa0..d4ca833c99c6 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 @@ -257,7 +257,11 @@ class Async{{service.name}}RestTransport(_Base{{ service.name }}RestTransport): resp = await self._interceptor.post_{{ method.name|snake_case }}(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_{{ method.name|snake_case }}_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2389): #} {# Depending how we want to log (a) receiving a streaming response vs (b) exposing the next streamed item to the user, we could possibly want to log something here #} {# (a) should always happen in api-core #} diff --git a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 index ab53d4699321..530d109d3f6a 100644 --- a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 +++ b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 @@ -2817,6 +2817,97 @@ def test_{{ service.name|snake_case }}_base_transport_wrap_async_method_older_ap assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_{{ service.name|snake_case }}_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_{{ service.name|snake_case }}_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_{{ service.name|snake_case }}_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_{{ service.name|snake_case }}_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] {% endif %} {% endblock %} From 91ac84af3594da563f9d0e6d2d39cae8fa743bdc Mon Sep 17 00:00:00 2001 From: Daniel Sanche Date: Thu, 12 Nov 2026 20:42:59 -0700 Subject: [PATCH 2/4] update goldens --- .../services/asset_service/async_client.py | 6 +- .../asset_v1/services/asset_service/client.py | 6 +- .../services/asset_service/transports/grpc.py | 6 +- .../asset_service/transports/grpc_asyncio.py | 6 +- .../services/asset_service/transports/rest.py | 276 +++++++-- .../unit/gapic/asset_v1/test_asset_service.py | 91 +++ .../services/iam_credentials/async_client.py | 6 +- .../services/iam_credentials/client.py | 6 +- .../iam_credentials/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../iam_credentials/transports/rest.py | 48 +- .../credentials_v1/test_iam_credentials.py | 91 +++ .../services/eventarc/async_client.py | 6 +- .../eventarc_v1/services/eventarc/client.py | 6 +- .../services/eventarc/transports/grpc.py | 6 +- .../eventarc/transports/grpc_asyncio.py | 6 +- .../services/eventarc/transports/rest.py | 564 +++++++++++++++--- .../unit/gapic/eventarc_v1/test_eventarc.py | 91 +++ .../config_service_v2/async_client.py | 6 +- .../services/config_service_v2/client.py | 6 +- .../config_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../logging_service_v2/async_client.py | 6 +- .../services/logging_service_v2/client.py | 6 +- .../logging_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../metrics_service_v2/async_client.py | 6 +- .../services/metrics_service_v2/client.py | 6 +- .../metrics_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../logging_v2/test_config_service_v2.py | 91 +++ .../logging_v2/test_logging_service_v2.py | 91 +++ .../logging_v2/test_metrics_service_v2.py | 91 +++ .../config_service_v2/async_client.py | 6 +- .../services/config_service_v2/client.py | 6 +- .../config_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../logging_service_v2/async_client.py | 6 +- .../services/logging_service_v2/client.py | 6 +- .../logging_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../metrics_service_v2/async_client.py | 6 +- .../services/metrics_service_v2/client.py | 6 +- .../metrics_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../logging_v2/test_config_service_v2.py | 91 +++ .../logging_v2/test_logging_service_v2.py | 91 +++ .../logging_v2/test_metrics_service_v2.py | 91 +++ .../services/cloud_redis/async_client.py | 6 +- .../redis_v1/services/cloud_redis/client.py | 6 +- .../services/cloud_redis/transports/grpc.py | 6 +- .../cloud_redis/transports/grpc_asyncio.py | 6 +- .../services/cloud_redis/transports/rest.py | 204 +++++-- .../cloud_redis/transports/rest_asyncio.py | 204 +++++-- .../unit/gapic/redis_v1/test_cloud_redis.py | 91 +++ .../services/cloud_redis/async_client.py | 6 +- .../redis_v1/services/cloud_redis/client.py | 6 +- .../services/cloud_redis/transports/grpc.py | 6 +- .../cloud_redis/transports/grpc_asyncio.py | 6 +- .../services/cloud_redis/transports/rest.py | 132 +++- .../cloud_redis/transports/rest_asyncio.py | 132 +++- .../unit/gapic/redis_v1/test_cloud_redis.py | 91 +++ .../services/echo/async_client.py | 6 +- .../showcase_v1beta1/services/echo/client.py | 6 +- .../services/echo/transports/grpc.py | 6 +- .../services/echo/transports/grpc_asyncio.py | 6 +- .../services/echo/transports/rest.py | 204 +++++-- .../services/identity/async_client.py | 6 +- .../services/identity/client.py | 6 +- .../services/identity/transports/grpc.py | 6 +- .../identity/transports/grpc_asyncio.py | 6 +- .../services/identity/transports/rest.py | 150 ++++- .../services/messaging/async_client.py | 6 +- .../services/messaging/client.py | 6 +- .../services/messaging/transports/grpc.py | 6 +- .../messaging/transports/grpc_asyncio.py | 6 +- .../services/messaging/transports/rest.py | 228 +++++-- .../resumable_upload_service/async_client.py | 6 +- .../resumable_upload_service/client.py | 6 +- .../transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../transports/rest.py | 96 ++- .../services/sequence_service/async_client.py | 6 +- .../services/sequence_service/client.py | 6 +- .../sequence_service/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../sequence_service/transports/rest.py | 162 ++++- .../services/testing/async_client.py | 6 +- .../services/testing/client.py | 6 +- .../services/testing/transports/grpc.py | 6 +- .../testing/transports/grpc_asyncio.py | 6 +- .../services/testing/transports/rest.py | 180 +++++- .../unit/gapic/showcase_v1beta1/test_echo.py | 91 +++ .../gapic/showcase_v1beta1/test_identity.py | 91 +++ .../gapic/showcase_v1beta1/test_messaging.py | 91 +++ .../test_resumable_upload_service.py | 91 +++ .../showcase_v1beta1/test_sequence_service.py | 91 +++ .../gapic/showcase_v1beta1/test_testing.py | 91 +++ .../storage_batch_operations/async_client.py | 6 +- .../storage_batch_operations/client.py | 6 +- .../transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../transports/rest.py | 138 ++++- .../test_storage_batch_operations.py | 91 +++ 104 files changed, 4263 insertions(+), 525 deletions(-) diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py index 2aa9f87cfc58..0d6bbd6ff47e 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py @@ -262,7 +262,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.asset_v1.AssetServiceAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py index cb64bd630fb1..c8b1f8acadac 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py @@ -574,7 +574,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.asset_v1.AssetServiceClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py index b7e7d2fb3cf3..b1c77b6643ee 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py @@ -59,7 +59,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py index ed98a87ac789..fe675f8f0a3f 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py @@ -59,7 +59,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py index a2dde35054eb..7c53899191a7 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py @@ -1272,7 +1272,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1320,7 +1324,11 @@ def __call__(self, resp = self._interceptor.post_analyze_iam_policy(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_iam_policy_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.AnalyzeIamPolicyResponse.to_json(response) except: @@ -1425,7 +1433,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1472,7 +1484,11 @@ def __call__(self, resp = self._interceptor.post_analyze_iam_policy_longrunning(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_iam_policy_longrunning_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1574,7 +1590,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1622,7 +1642,11 @@ def __call__(self, resp = self._interceptor.post_analyze_move(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_move_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.AnalyzeMoveResponse.to_json(response) except: @@ -1724,7 +1748,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1772,7 +1800,11 @@ def __call__(self, resp = self._interceptor.post_analyze_org_policies(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_org_policies_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.AnalyzeOrgPoliciesResponse.to_json(response) except: @@ -1875,7 +1907,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1923,7 +1959,11 @@ def __call__(self, resp = self._interceptor.post_analyze_org_policy_governed_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_org_policy_governed_assets_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.AnalyzeOrgPolicyGovernedAssetsResponse.to_json(response) except: @@ -2026,7 +2066,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2074,7 +2118,11 @@ def __call__(self, resp = self._interceptor.post_analyze_org_policy_governed_containers(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_org_policy_governed_containers_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.AnalyzeOrgPolicyGovernedContainersResponse.to_json(response) except: @@ -2173,7 +2221,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2221,7 +2273,11 @@ def __call__(self, resp = self._interceptor.post_batch_get_assets_history(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_batch_get_assets_history_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.BatchGetAssetsHistoryResponse.to_json(response) except: @@ -2324,7 +2380,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2372,7 +2432,11 @@ def __call__(self, resp = self._interceptor.post_batch_get_effective_iam_policies(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_batch_get_effective_iam_policies_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.BatchGetEffectiveIamPoliciesResponse.to_json(response) except: @@ -2480,7 +2544,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2529,7 +2597,11 @@ def __call__(self, resp = self._interceptor.post_create_feed(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_feed_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.Feed.to_json(response) except: @@ -2631,7 +2703,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2680,7 +2756,11 @@ def __call__(self, resp = self._interceptor.post_create_saved_query(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_saved_query_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.SavedQuery.to_json(response) except: @@ -2775,7 +2855,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2889,7 +2973,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3011,7 +3099,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3058,7 +3150,11 @@ def __call__(self, resp = self._interceptor.post_export_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_export_assets_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3165,7 +3261,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3213,7 +3313,11 @@ def __call__(self, resp = self._interceptor.post_get_feed(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_feed_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.Feed.to_json(response) except: @@ -3314,7 +3418,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3362,7 +3470,11 @@ def __call__(self, resp = self._interceptor.post_get_saved_query(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_saved_query_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.SavedQuery.to_json(response) except: @@ -3461,7 +3573,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3509,7 +3625,11 @@ def __call__(self, resp = self._interceptor.post_list_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_assets_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.ListAssetsResponse.to_json(response) except: @@ -3608,7 +3728,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3656,7 +3780,11 @@ def __call__(self, resp = self._interceptor.post_list_feeds(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_feeds_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.ListFeedsResponse.to_json(response) except: @@ -3755,7 +3883,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3803,7 +3935,11 @@ def __call__(self, resp = self._interceptor.post_list_saved_queries(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_saved_queries_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.ListSavedQueriesResponse.to_json(response) except: @@ -3903,7 +4039,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3952,7 +4092,11 @@ def __call__(self, resp = self._interceptor.post_query_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_query_assets_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.QueryAssetsResponse.to_json(response) except: @@ -4051,7 +4195,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4099,7 +4247,11 @@ def __call__(self, resp = self._interceptor.post_search_all_iam_policies(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_search_all_iam_policies_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.SearchAllIamPoliciesResponse.to_json(response) except: @@ -4198,7 +4350,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4246,7 +4402,11 @@ def __call__(self, resp = self._interceptor.post_search_all_resources(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_search_all_resources_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.SearchAllResourcesResponse.to_json(response) except: @@ -4354,7 +4514,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4403,7 +4567,11 @@ def __call__(self, resp = self._interceptor.post_update_feed(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_feed_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.Feed.to_json(response) except: @@ -4505,7 +4673,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4554,7 +4726,11 @@ def __call__(self, resp = self._interceptor.post_update_saved_query(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_saved_query_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = asset_service.SavedQuery.to_json(response) except: @@ -4841,7 +5017,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4885,7 +5065,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py index b9dd7e19527a..81469c36292d 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py @@ -18751,3 +18751,94 @@ def test_asset_service_base_transport_wrap_async_method_older_api_core_fallbacks assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_asset_service_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_asset_service_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_asset_service_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_asset_service_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py index 2488fbb1616e..565c096ed453 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py @@ -253,7 +253,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.iam.credentials_v1.IAMCredentialsAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py index f72f88247061..6f1f38e6c9a6 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py @@ -511,7 +511,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.iam.credentials_v1.IAMCredentialsClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py index 8dae63762125..a1f950cdc79b 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py @@ -56,7 +56,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py index caa5530bb88e..d75f12794d61 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py @@ -56,7 +56,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py index fff3c34c4c26..594edfcbb7de 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py @@ -451,7 +451,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -500,7 +504,11 @@ def __call__(self, resp = self._interceptor.post_generate_access_token(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_generate_access_token_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = common.GenerateAccessTokenResponse.to_json(response) except: @@ -600,7 +608,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -649,7 +661,11 @@ def __call__(self, resp = self._interceptor.post_generate_id_token(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_generate_id_token_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = common.GenerateIdTokenResponse.to_json(response) except: @@ -749,7 +765,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -798,7 +818,11 @@ def __call__(self, resp = self._interceptor.post_sign_blob(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_sign_blob_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = common.SignBlobResponse.to_json(response) except: @@ -898,7 +922,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -947,7 +975,11 @@ def __call__(self, resp = self._interceptor.post_sign_jwt(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_sign_jwt_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = common.SignJwtResponse.to_json(response) except: diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py index 8c7601cf7d18..ff223857df2f 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py @@ -4797,3 +4797,94 @@ def test_iam_credentials_base_transport_wrap_async_method_older_api_core_fallbac assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_iam_credentials_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_iam_credentials_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_iam_credentials_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_iam_credentials_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py index df1beed698ee..18ba3ecd72d1 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py @@ -301,7 +301,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.eventarc_v1.EventarcAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py index 205b75d4a78c..ba46c0708c8d 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py @@ -694,7 +694,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.eventarc_v1.EventarcClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py index 684cac7b9145..8fa8e146cada 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py @@ -71,7 +71,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py index 344511242b78..fb5d28e0d8f1 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py @@ -71,7 +71,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py index f25dd893e29e..6f6b1de8baa6 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py @@ -2243,7 +2243,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2290,7 +2294,11 @@ def __call__(self, resp = self._interceptor.post_create_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_channel_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2394,7 +2402,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2441,7 +2453,11 @@ def __call__(self, resp = self._interceptor.post_create_channel_connection(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_channel_connection_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2545,7 +2561,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2592,7 +2612,11 @@ def __call__(self, resp = self._interceptor.post_create_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_enrollment_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2696,7 +2720,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2743,7 +2771,11 @@ def __call__(self, resp = self._interceptor.post_create_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_google_api_source_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2847,7 +2879,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2894,7 +2930,11 @@ def __call__(self, resp = self._interceptor.post_create_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_message_bus_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2998,7 +3038,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3045,7 +3089,11 @@ def __call__(self, resp = self._interceptor.post_create_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_pipeline_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3149,7 +3197,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3196,7 +3248,11 @@ def __call__(self, resp = self._interceptor.post_create_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_trigger_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3299,7 +3355,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3345,7 +3405,11 @@ def __call__(self, resp = self._interceptor.post_delete_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_channel_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3448,7 +3512,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3494,7 +3562,11 @@ def __call__(self, resp = self._interceptor.post_delete_channel_connection(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_channel_connection_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3597,7 +3669,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3643,7 +3719,11 @@ def __call__(self, resp = self._interceptor.post_delete_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_enrollment_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3746,7 +3826,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3792,7 +3876,11 @@ def __call__(self, resp = self._interceptor.post_delete_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_google_api_source_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3895,7 +3983,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3941,7 +4033,11 @@ def __call__(self, resp = self._interceptor.post_delete_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_message_bus_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -4044,7 +4140,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4090,7 +4190,11 @@ def __call__(self, resp = self._interceptor.post_delete_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_pipeline_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -4193,7 +4297,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4239,7 +4347,11 @@ def __call__(self, resp = self._interceptor.post_delete_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_trigger_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -4347,7 +4459,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4395,7 +4511,11 @@ def __call__(self, resp = self._interceptor.post_get_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_channel_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = channel.Channel.to_json(response) except: @@ -4502,7 +4622,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4550,7 +4674,11 @@ def __call__(self, resp = self._interceptor.post_get_channel_connection(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_channel_connection_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = channel_connection.ChannelConnection.to_json(response) except: @@ -4656,7 +4784,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4704,7 +4836,11 @@ def __call__(self, resp = self._interceptor.post_get_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_enrollment_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = enrollment.Enrollment.to_json(response) except: @@ -4807,7 +4943,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4855,7 +4995,11 @@ def __call__(self, resp = self._interceptor.post_get_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_google_api_source_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = google_api_source.GoogleApiSource.to_json(response) except: @@ -4963,7 +5107,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5011,7 +5159,11 @@ def __call__(self, resp = self._interceptor.post_get_google_channel_config(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_google_channel_config_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = google_channel_config.GoogleChannelConfig.to_json(response) except: @@ -5119,7 +5271,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5167,7 +5323,11 @@ def __call__(self, resp = self._interceptor.post_get_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_message_bus_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = message_bus.MessageBus.to_json(response) except: @@ -5269,7 +5429,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5317,7 +5481,11 @@ def __call__(self, resp = self._interceptor.post_get_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_pipeline_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = pipeline.Pipeline.to_json(response) except: @@ -5419,7 +5587,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5467,7 +5639,11 @@ def __call__(self, resp = self._interceptor.post_get_provider(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_provider_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = discovery.Provider.to_json(response) except: @@ -5569,7 +5745,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5617,7 +5797,11 @@ def __call__(self, resp = self._interceptor.post_get_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_trigger_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = trigger.Trigger.to_json(response) except: @@ -5719,7 +5903,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5767,7 +5955,11 @@ def __call__(self, resp = self._interceptor.post_list_channel_connections(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_channel_connections_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListChannelConnectionsResponse.to_json(response) except: @@ -5867,7 +6059,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5915,7 +6111,11 @@ def __call__(self, resp = self._interceptor.post_list_channels(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_channels_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListChannelsResponse.to_json(response) except: @@ -6015,7 +6215,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6063,7 +6267,11 @@ def __call__(self, resp = self._interceptor.post_list_enrollments(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_enrollments_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListEnrollmentsResponse.to_json(response) except: @@ -6165,7 +6373,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6213,7 +6425,11 @@ def __call__(self, resp = self._interceptor.post_list_google_api_sources(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_google_api_sources_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListGoogleApiSourcesResponse.to_json(response) except: @@ -6316,7 +6532,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6364,7 +6584,11 @@ def __call__(self, resp = self._interceptor.post_list_message_bus_enrollments(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_message_bus_enrollments_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListMessageBusEnrollmentsResponse.to_json(response) except: @@ -6466,7 +6690,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6514,7 +6742,11 @@ def __call__(self, resp = self._interceptor.post_list_message_buses(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_message_buses_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListMessageBusesResponse.to_json(response) except: @@ -6616,7 +6848,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6664,7 +6900,11 @@ def __call__(self, resp = self._interceptor.post_list_pipelines(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_pipelines_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListPipelinesResponse.to_json(response) except: @@ -6764,7 +7004,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6812,7 +7056,11 @@ def __call__(self, resp = self._interceptor.post_list_providers(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_providers_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListProvidersResponse.to_json(response) except: @@ -6912,7 +7160,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6960,7 +7212,11 @@ def __call__(self, resp = self._interceptor.post_list_triggers(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_triggers_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = eventarc.ListTriggersResponse.to_json(response) except: @@ -7064,7 +7320,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7111,7 +7371,11 @@ def __call__(self, resp = self._interceptor.post_update_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_channel_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7215,7 +7479,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7262,7 +7530,11 @@ def __call__(self, resp = self._interceptor.post_update_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_enrollment_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7366,7 +7638,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7413,7 +7689,11 @@ def __call__(self, resp = self._interceptor.post_update_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_google_api_source_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7523,7 +7803,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7572,7 +7856,11 @@ def __call__(self, resp = self._interceptor.post_update_google_channel_config(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_google_channel_config_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gce_google_channel_config.GoogleChannelConfig.to_json(response) except: @@ -7676,7 +7964,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7723,7 +8015,11 @@ def __call__(self, resp = self._interceptor.post_update_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_message_bus_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7827,7 +8123,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7874,7 +8174,11 @@ def __call__(self, resp = self._interceptor.post_update_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_pipeline_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7978,7 +8282,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8025,7 +8333,11 @@ def __call__(self, resp = self._interceptor.post_update_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_trigger_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8440,7 +8752,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8484,7 +8800,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8587,7 +8907,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8631,7 +8955,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8734,7 +9062,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8778,7 +9110,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8882,7 +9218,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8927,7 +9267,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9031,7 +9375,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9076,7 +9424,11 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9177,7 +9529,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9299,7 +9655,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9423,7 +9783,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9467,7 +9831,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9570,7 +9938,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9614,7 +9986,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py index 86fef1613499..a221aa8781b0 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py @@ -33854,3 +33854,94 @@ def test_eventarc_base_transport_wrap_async_method_older_api_core_fallbacks(monk assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_eventarc_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_eventarc_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_eventarc_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_eventarc_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py index fa65c790239b..d234a72f9cbd 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py @@ -257,7 +257,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.ConfigServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py index 8ff770a7acf4..2c1def209bfe 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py @@ -567,7 +567,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.ConfigServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py index e53299a7cf04..c9e7b0e86b07 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py @@ -59,7 +59,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py index 9997dc6d9ef7..f35e492aef60 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py @@ -59,7 +59,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py index 7e6d3d89278d..e932609563b6 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py @@ -242,7 +242,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py index 8548da4cb603..3b0c5e592493 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py @@ -498,7 +498,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py index 266d9083b341..7337914e53bf 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py @@ -58,7 +58,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py index 77a8d69009b3..8ae650a6bfa3 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py @@ -58,7 +58,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py index d606a3b942b6..f4e707c16d1f 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py @@ -243,7 +243,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.MetricsServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py index fe042f13fee4..b9ee5ec71ff3 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py @@ -499,7 +499,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.MetricsServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py index aa746fb22171..4b99ea32e0f1 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py @@ -58,7 +58,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py index 6effe18f939b..e937fe038658 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py @@ -58,7 +58,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py index f2a5fbe88df5..71d16fb7e96c 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py @@ -14348,3 +14348,94 @@ def test_config_service_v2_base_transport_wrap_async_method_older_api_core_fallb assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_config_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_config_service_v2_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_config_service_v2_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_config_service_v2_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py index 6173c39bb9bf..ba12df1d0894 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py @@ -4788,3 +4788,94 @@ def test_logging_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_logging_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_logging_service_v2_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_logging_service_v2_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_logging_service_v2_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py index 62b10a0b4b79..510fefda55b9 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py @@ -4588,3 +4588,94 @@ def test_metrics_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_metrics_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_metrics_service_v2_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py index e07647b9c164..b9491291f5a0 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py @@ -257,7 +257,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseConfigServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py index e17834023c12..b5383105a406 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py @@ -567,7 +567,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseConfigServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py index e53299a7cf04..c9e7b0e86b07 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py @@ -59,7 +59,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py index 9997dc6d9ef7..f35e492aef60 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py @@ -59,7 +59,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py index 7e6d3d89278d..e932609563b6 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py @@ -242,7 +242,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py index 8548da4cb603..3b0c5e592493 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py @@ -498,7 +498,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py index 266d9083b341..7337914e53bf 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py @@ -58,7 +58,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py index 77a8d69009b3..8ae650a6bfa3 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py @@ -58,7 +58,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py index 22460abe69ff..c794492b4ae3 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py @@ -243,7 +243,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseMetricsServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py index 9cb5795838c9..f4f94dbc0282 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py @@ -499,7 +499,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseMetricsServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py index aa746fb22171..4b99ea32e0f1 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py @@ -58,7 +58,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py index 6effe18f939b..e937fe038658 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py @@ -58,7 +58,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py index c6052913a6f3..1696024e31f6 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py @@ -14348,3 +14348,94 @@ def test_config_service_v2_base_transport_wrap_async_method_older_api_core_fallb assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_config_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_config_service_v2_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_config_service_v2_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_config_service_v2_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py index 6173c39bb9bf..ba12df1d0894 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py @@ -4788,3 +4788,94 @@ def test_logging_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_logging_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_logging_service_v2_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_logging_service_v2_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_logging_service_v2_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py index 5eca8fde6778..2cba6c3932c0 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py @@ -4588,3 +4588,94 @@ def test_metrics_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_metrics_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_metrics_service_v2_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py index 88338a91e016..d93b6dc23d65 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py @@ -270,7 +270,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py index 6db0da86a58d..8912c2d6335c 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py @@ -565,7 +565,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py index 53dc638ad6d3..be3b545b460f 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py @@ -59,7 +59,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py index 4c95082b021d..489c0e2a0cdd 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py @@ -59,7 +59,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 282ad08fec80..03e018aaca7d 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -981,7 +981,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1028,7 +1032,11 @@ def __call__(self, resp = self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1131,7 +1139,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1177,7 +1189,11 @@ def __call__(self, resp = self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1281,7 +1297,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1328,7 +1348,11 @@ def __call__(self, resp = self._interceptor.post_export_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_export_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1432,7 +1456,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1479,7 +1507,11 @@ def __call__(self, resp = self._interceptor.post_failover_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_failover_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1579,7 +1611,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1627,7 +1663,11 @@ def __call__(self, resp = self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1727,7 +1767,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1775,7 +1819,11 @@ def __call__(self, resp = self._interceptor.post_get_instance_auth_string(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_instance_auth_string_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.InstanceAuthString.to_json(response) except: @@ -1879,7 +1927,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1926,7 +1978,11 @@ def __call__(self, resp = self._interceptor.post_import_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_import_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2028,7 +2084,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2076,7 +2136,11 @@ def __call__(self, resp = self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -2180,7 +2244,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2227,7 +2295,11 @@ def __call__(self, resp = self._interceptor.post_reschedule_maintenance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_reschedule_maintenance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2331,7 +2403,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2378,7 +2454,11 @@ def __call__(self, resp = self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2482,7 +2562,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2529,7 +2613,11 @@ def __call__(self, resp = self._interceptor.post_upgrade_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_upgrade_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2720,7 +2808,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2764,7 +2856,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2867,7 +2963,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2911,7 +3011,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3011,7 +3115,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3132,7 +3240,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3256,7 +3368,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3300,7 +3416,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3403,7 +3523,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3447,7 +3571,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3551,7 +3679,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3596,7 +3728,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_wait_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index 564920114b7d..77cd0ec7bfb5 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -1023,7 +1023,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1076,7 +1080,11 @@ async def __call__(self, resp = await self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1180,7 +1188,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1232,7 +1244,11 @@ async def __call__(self, resp = await self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1337,7 +1353,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1390,7 +1410,11 @@ async def __call__(self, resp = await self._interceptor.post_export_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_export_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1495,7 +1519,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1548,7 +1576,11 @@ async def __call__(self, resp = await self._interceptor.post_failover_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_failover_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1649,7 +1681,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1701,7 +1737,11 @@ async def __call__(self, resp = await self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1802,7 +1842,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1854,7 +1898,11 @@ async def __call__(self, resp = await self._interceptor.post_get_instance_auth_string(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_get_instance_auth_string_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.InstanceAuthString.to_json(response) except: @@ -1959,7 +2007,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2012,7 +2064,11 @@ async def __call__(self, resp = await self._interceptor.post_import_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_import_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2115,7 +2171,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2167,7 +2227,11 @@ async def __call__(self, resp = await self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -2272,7 +2336,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2325,7 +2393,11 @@ async def __call__(self, resp = await self._interceptor.post_reschedule_maintenance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_reschedule_maintenance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2430,7 +2502,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2483,7 +2559,11 @@ async def __call__(self, resp = await self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2588,7 +2668,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2641,7 +2725,11 @@ async def __call__(self, resp = await self._interceptor.post_upgrade_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_upgrade_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2867,7 +2955,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2915,7 +3007,11 @@ async def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3018,7 +3114,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3066,7 +3166,11 @@ async def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3166,7 +3270,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3291,7 +3399,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3419,7 +3531,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3467,7 +3583,11 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3570,7 +3690,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3618,7 +3742,11 @@ async def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3722,7 +3850,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3771,7 +3903,11 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_wait_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py index 88e200e064a5..2e133edb1b54 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py @@ -13642,3 +13642,94 @@ def test_cloud_redis_base_transport_wrap_async_method_older_api_core_fallbacks(m assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_cloud_redis_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_cloud_redis_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_cloud_redis_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_cloud_redis_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py index e67da5b146ab..8f58ae7a20db 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py @@ -270,7 +270,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py index 17f82b11a062..070d58ffb608 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py @@ -565,7 +565,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py index e313f7b527d7..6c46cd3db868 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py @@ -59,7 +59,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py index 9d170d41dec2..3f8b31dd269f 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py @@ -59,7 +59,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 4543496d4cd9..410d8dc09ed0 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -717,7 +717,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -764,7 +768,11 @@ def __call__(self, resp = self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -867,7 +875,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -913,7 +925,11 @@ def __call__(self, resp = self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1013,7 +1029,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1061,7 +1081,11 @@ def __call__(self, resp = self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1163,7 +1187,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1211,7 +1239,11 @@ def __call__(self, resp = self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -1315,7 +1347,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1362,7 +1398,11 @@ def __call__(self, resp = self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1505,7 +1545,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1549,7 +1593,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1652,7 +1700,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1696,7 +1748,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1796,7 +1852,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1917,7 +1977,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2041,7 +2105,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2085,7 +2153,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2188,7 +2260,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2232,7 +2308,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2336,7 +2416,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2381,7 +2465,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_wait_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index dfced5164721..90aa41086acd 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -723,7 +723,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -776,7 +780,11 @@ async def __call__(self, resp = await self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -880,7 +888,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -932,7 +944,11 @@ async def __call__(self, resp = await self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1033,7 +1049,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1085,7 +1105,11 @@ async def __call__(self, resp = await self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1188,7 +1212,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1240,7 +1268,11 @@ async def __call__(self, resp = await self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -1345,7 +1377,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1398,7 +1434,11 @@ async def __call__(self, resp = await self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1588,7 +1628,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1636,7 +1680,11 @@ async def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1739,7 +1787,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1787,7 +1839,11 @@ async def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1887,7 +1943,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2012,7 +2072,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2140,7 +2204,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2188,7 +2256,11 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2291,7 +2363,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2339,7 +2415,11 @@ async def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2443,7 +2523,11 @@ async def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2492,7 +2576,11 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_wait_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py index e91d07951808..11d0f250ed28 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py @@ -8862,3 +8862,94 @@ def test_cloud_redis_base_transport_wrap_async_method_older_api_core_fallbacks(m assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_cloud_redis_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_cloud_redis_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_cloud_redis_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_cloud_redis_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py index 08e073fc4054..1cfdf707dbd7 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py @@ -259,7 +259,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.EchoAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py index 50586844102c..7a8d78af0f4a 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py @@ -508,7 +508,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.EchoClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py index 6fed4c1dd2f9..aae0259fefb0 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py @@ -61,7 +61,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py index dd650b16ad33..ecbf8a1d8952 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py @@ -61,7 +61,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py index 0608feae5957..0b87ebae4de4 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py @@ -909,7 +909,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -958,7 +962,11 @@ def __call__(self, resp = self._interceptor.post_block(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_block_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_echo.BlockResponse.to_json(response) except: @@ -1091,7 +1099,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1140,7 +1152,11 @@ def __call__(self, resp = self._interceptor.post_echo(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_echo_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_echo.EchoResponse.to_json(response) except: @@ -1243,7 +1259,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1292,7 +1312,11 @@ def __call__(self, resp = self._interceptor.post_echo_error_details(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_echo_error_details_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_echo.EchoErrorDetailsResponse.to_json(response) except: @@ -1396,7 +1420,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1442,7 +1470,11 @@ def __call__(self, resp = self._interceptor.post_expand(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_expand_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER http_response = { "headers": dict(response.headers), "status": response.status_code, @@ -1541,7 +1573,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1590,7 +1626,11 @@ def __call__(self, resp = self._interceptor.post_fail_echo_with_details(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_fail_echo_with_details_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_echo.FailEchoWithDetailsResponse.to_json(response) except: @@ -1693,7 +1733,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1742,7 +1786,11 @@ def __call__(self, resp = self._interceptor.post_paged_expand(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_paged_expand_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_echo.PagedExpandResponse.to_json(response) except: @@ -1849,7 +1897,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1898,7 +1950,11 @@ def __call__(self, resp = self._interceptor.post_paged_expand_legacy(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_paged_expand_legacy_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_echo.PagedExpandResponse.to_json(response) except: @@ -2000,7 +2056,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2049,7 +2109,11 @@ def __call__(self, resp = self._interceptor.post_paged_expand_legacy_mapped(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_paged_expand_legacy_mapped_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_echo.PagedExpandLegacyMappedResponse.to_json(response) except: @@ -2152,7 +2216,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2199,7 +2267,11 @@ def __call__(self, resp = self._interceptor.post_wait(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_wait_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2390,7 +2462,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2434,7 +2510,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2537,7 +2617,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2581,7 +2665,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2685,7 +2773,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2730,7 +2822,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2833,7 +2929,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2877,7 +2977,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2981,7 +3085,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3026,7 +3134,11 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3129,7 +3241,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3173,7 +3289,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3276,7 +3396,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3320,7 +3444,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3420,7 +3548,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3541,7 +3673,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py index 8885c28c8935..e6ff9173ff73 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py @@ -246,7 +246,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.IdentityAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py index 5ecb1f9fa8f7..d9ea6612f9f2 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py @@ -504,7 +504,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.IdentityClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py index 1c44b011abfd..ef779d79b77c 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py @@ -61,7 +61,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py index 3d1e93a2a8cf..b6e8446a3847 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py @@ -61,7 +61,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py index 1ff8e157b8d8..4814cd582717 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py @@ -646,7 +646,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -695,7 +699,11 @@ def __call__(self, resp = self._interceptor.post_create_user(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_user_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = identity.User.to_json(response) except: @@ -792,7 +800,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -912,7 +924,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -960,7 +976,11 @@ def __call__(self, resp = self._interceptor.post_get_user(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_user_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = identity.User.to_json(response) except: @@ -1064,7 +1084,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1112,7 +1136,11 @@ def __call__(self, resp = self._interceptor.post_list_users(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_users_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = identity.ListUsersResponse.to_json(response) except: @@ -1214,7 +1242,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1263,7 +1295,11 @@ def __call__(self, resp = self._interceptor.post_update_user(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_user_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = identity.User.to_json(response) except: @@ -1406,7 +1442,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1450,7 +1490,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1553,7 +1597,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1597,7 +1645,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1701,7 +1753,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1746,7 +1802,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1849,7 +1909,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1893,7 +1957,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1997,7 +2065,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2042,7 +2114,11 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2145,7 +2221,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2189,7 +2269,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2292,7 +2376,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2336,7 +2424,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2436,7 +2528,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2557,7 +2653,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py index f8c65eb411d8..dd80082e1304 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py @@ -256,7 +256,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.MessagingAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py index ccd6580ad9c9..52e2c0eeb6bc 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py @@ -532,7 +532,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.MessagingClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py index 9eabd7fd246d..d2ec94705164 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py @@ -62,7 +62,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py index db5dca52d7f1..da8a4409be2e 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py @@ -62,7 +62,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py index 0cfa8094cec7..cbff605cf115 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py @@ -992,7 +992,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1041,7 +1045,11 @@ def __call__(self, resp = self._interceptor.post_create_blurb(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_blurb_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.Blurb.to_json(response) except: @@ -1143,7 +1151,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1192,7 +1204,11 @@ def __call__(self, resp = self._interceptor.post_create_room(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_room_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.Room.to_json(response) except: @@ -1289,7 +1305,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1405,7 +1425,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1528,7 +1552,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1576,7 +1604,11 @@ def __call__(self, resp = self._interceptor.post_get_blurb(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_blurb_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.Blurb.to_json(response) except: @@ -1677,7 +1709,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1725,7 +1761,11 @@ def __call__(self, resp = self._interceptor.post_get_room(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_room_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.Room.to_json(response) except: @@ -1829,7 +1869,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1877,7 +1921,11 @@ def __call__(self, resp = self._interceptor.post_list_blurbs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_blurbs_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.ListBlurbsResponse.to_json(response) except: @@ -1981,7 +2029,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2029,7 +2081,11 @@ def __call__(self, resp = self._interceptor.post_list_rooms(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_rooms_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.ListRoomsResponse.to_json(response) except: @@ -2134,7 +2190,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2181,7 +2241,11 @@ def __call__(self, resp = self._interceptor.post_search_blurbs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_search_blurbs_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2300,7 +2364,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2346,7 +2414,11 @@ def __call__(self, resp = self._interceptor.post_stream_blurbs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_stream_blurbs_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER http_response = { "headers": dict(response.headers), "status": response.status_code, @@ -2446,7 +2518,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2495,7 +2571,11 @@ def __call__(self, resp = self._interceptor.post_update_blurb(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_blurb_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.Blurb.to_json(response) except: @@ -2597,7 +2677,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2646,7 +2730,11 @@ def __call__(self, resp = self._interceptor.post_update_room(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_room_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = messaging.Room.to_json(response) except: @@ -2861,7 +2949,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2905,7 +2997,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3008,7 +3104,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3052,7 +3152,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3156,7 +3260,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3201,7 +3309,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3304,7 +3416,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3348,7 +3464,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3452,7 +3572,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3497,7 +3621,11 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3600,7 +3728,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3644,7 +3776,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3747,7 +3883,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3791,7 +3931,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3891,7 +4035,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4012,7 +4160,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py index adb806e016af..7d84d7a23a0f 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py @@ -246,7 +246,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.ResumableUploadServiceAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py index 3697975f1947..88113b83b80d 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py @@ -495,7 +495,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.ResumableUploadServiceClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py index fd81936460f7..2a6dae3b16a8 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py @@ -63,7 +63,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py index c49c8aaf5b1b..93bd953d8984 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py @@ -66,7 +66,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py index 40cdeb436e98..873d45068d4e 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py @@ -555,7 +555,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -599,7 +603,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -702,7 +710,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -746,7 +758,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -850,7 +866,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -895,7 +915,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -998,7 +1022,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1042,7 +1070,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1146,7 +1178,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1191,7 +1227,11 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1294,7 +1334,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1338,7 +1382,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1441,7 +1489,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1485,7 +1537,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1585,7 +1641,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1706,7 +1766,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py index 62ca88fe4b26..426dbd42cadf 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py @@ -254,7 +254,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.SequenceServiceAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py index ec443356c2bf..3afb1ab616db 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py @@ -539,7 +539,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.SequenceServiceClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py index 38a445e24e6c..efd355db388f 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py @@ -62,7 +62,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py index a6eefa915155..d4b8baa3f0f5 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py @@ -62,7 +62,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py index 472dfeec16f1..c61709776cb0 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py @@ -688,7 +688,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -813,7 +817,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -859,7 +867,11 @@ def __call__(self, resp = self._interceptor.post_attempt_streaming_sequence(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_attempt_streaming_sequence_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER http_response = { "headers": dict(response.headers), "status": response.status_code, @@ -958,7 +970,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1007,7 +1023,11 @@ def __call__(self, resp = self._interceptor.post_create_sequence(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_sequence_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = gs_sequence.Sequence.to_json(response) except: @@ -1112,7 +1132,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1161,7 +1185,11 @@ def __call__(self, resp = self._interceptor.post_create_streaming_sequence(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_streaming_sequence_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = sequence.StreamingSequence.to_json(response) except: @@ -1262,7 +1290,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1310,7 +1342,11 @@ def __call__(self, resp = self._interceptor.post_get_sequence_report(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_sequence_report_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = sequence.SequenceReport.to_json(response) except: @@ -1412,7 +1448,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1460,7 +1500,11 @@ def __call__(self, resp = self._interceptor.post_get_streaming_sequence_report(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_streaming_sequence_report_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = sequence.StreamingSequenceReport.to_json(response) except: @@ -1611,7 +1655,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1655,7 +1703,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1758,7 +1810,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1802,7 +1858,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1906,7 +1966,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1951,7 +2015,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2054,7 +2122,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2098,7 +2170,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2202,7 +2278,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2247,7 +2327,11 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2350,7 +2434,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2394,7 +2482,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2497,7 +2589,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2541,7 +2637,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2641,7 +2741,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2762,7 +2866,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py index ba770a7f641e..b16875ddec1e 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py @@ -256,7 +256,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.TestingAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py index 5b374e7544cd..652cae3bb194 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py @@ -532,7 +532,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.TestingClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py index 43b9ea5b7c3d..afbaabe9c9a6 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py @@ -61,7 +61,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py index 0595983ce44c..83c5188c61e9 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py @@ -61,7 +61,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py index 7aac1f262a8d..8a0ce641e7b8 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py @@ -758,7 +758,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -807,7 +811,11 @@ def __call__(self, resp = self._interceptor.post_create_session(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_session_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = testing.Session.to_json(response) except: @@ -902,7 +910,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1016,7 +1028,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1142,7 +1158,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1190,7 +1210,11 @@ def __call__(self, resp = self._interceptor.post_get_session(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_session_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = testing.Session.to_json(response) except: @@ -1290,7 +1314,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1338,7 +1366,11 @@ def __call__(self, resp = self._interceptor.post_list_sessions(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_sessions_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = testing.ListSessionsResponse.to_json(response) except: @@ -1439,7 +1471,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1487,7 +1523,11 @@ def __call__(self, resp = self._interceptor.post_list_tests(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_tests_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = testing.ListTestsResponse.to_json(response) except: @@ -1589,7 +1629,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1637,7 +1681,11 @@ def __call__(self, resp = self._interceptor.post_report_session(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_report_session_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = testing.ReportSessionResponse.to_json(response) except: @@ -1736,7 +1784,11 @@ def __call__(self, rest_numeric_enums=True, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1784,7 +1836,11 @@ def __call__(self, resp = self._interceptor.post_verify_test(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_verify_test_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = testing.VerifyTestResponse.to_json(response) except: @@ -1951,7 +2007,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1995,7 +2055,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2098,7 +2162,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2142,7 +2210,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2246,7 +2318,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2291,7 +2367,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2394,7 +2474,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2438,7 +2522,11 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2542,7 +2630,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2587,7 +2679,11 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2690,7 +2786,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2734,7 +2834,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2837,7 +2941,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2881,7 +2989,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2981,7 +3093,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3102,7 +3218,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py index 11c8bc0ee587..98e55de0c084 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py @@ -10121,3 +10121,94 @@ def test_echo_base_transport_wrap_async_method_older_api_core_fallbacks(monkeypa assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_echo_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_echo_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_echo_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_echo_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py index 556c1228c6cb..3e9037417aa3 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py @@ -7228,3 +7228,94 @@ def test_identity_base_transport_wrap_async_method_older_api_core_fallbacks(monk assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_identity_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_identity_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_identity_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_identity_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py index 0dc1fa615d4d..a95accee268f 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py @@ -12128,3 +12128,94 @@ def test_messaging_base_transport_wrap_async_method_older_api_core_fallbacks(mon assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_messaging_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_messaging_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_messaging_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_messaging_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py index f354e167b850..1ca0c22282cb 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py @@ -4821,3 +4821,94 @@ def test_resumable_upload_service_base_transport_wrap_async_method_older_api_cor assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_resumable_upload_service_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_resumable_upload_service_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_resumable_upload_service_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_resumable_upload_service_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py index 1b64c7e1e271..b9462975377a 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py @@ -7910,3 +7910,94 @@ def test_sequence_service_base_transport_wrap_async_method_older_api_core_fallba assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_sequence_service_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_sequence_service_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_sequence_service_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_sequence_service_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py index e453f8c98db9..7cb09435855b 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py @@ -8099,3 +8099,94 @@ def test_testing_base_transport_wrap_async_method_older_api_core_fallbacks(monke assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_testing_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_testing_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_testing_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_testing_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py index ecbbc14428e2..c1a9df8b95bb 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py @@ -259,7 +259,11 @@ def __init__(self, *, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.storagebatchoperations_v1.StorageBatchOperationsAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py index f73edbb23fc5..dee5b9fa1009 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py @@ -535,7 +535,11 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.storagebatchoperations_v1.StorageBatchOperationsClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py index aa31ac481fe9..9cc9aeb05dd9 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py @@ -61,7 +61,11 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py index d16cf16fd63b..2515ecd543be 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py @@ -61,7 +61,11 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) + logging_enabled = ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(std_logging.DEBUG) + and _LOGGER.hasHandlers() + ) if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py index f1f797714c66..054dc001d66d 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py @@ -728,7 +728,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -777,7 +781,11 @@ def __call__(self, resp = self._interceptor.post_cancel_job(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_cancel_job_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = storage_batch_operations.CancelJobResponse.to_json(response) except: @@ -880,7 +888,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -927,7 +939,11 @@ def __call__(self, resp = self._interceptor.post_create_job(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_job_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1022,7 +1038,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1143,7 +1163,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1191,7 +1215,11 @@ def __call__(self, resp = self._interceptor.post_get_bucket_operation(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_bucket_operation_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = storage_batch_operations_types.BucketOperation.to_json(response) except: @@ -1292,7 +1320,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1340,7 +1372,11 @@ def __call__(self, resp = self._interceptor.post_get_job(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_job_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = storage_batch_operations_types.Job.to_json(response) except: @@ -1442,7 +1478,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1490,7 +1530,11 @@ def __call__(self, resp = self._interceptor.post_list_bucket_operations(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_bucket_operations_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = storage_batch_operations.ListBucketOperationsResponse.to_json(response) except: @@ -1589,7 +1633,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1637,7 +1685,11 @@ def __call__(self, resp = self._interceptor.post_list_jobs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_jobs_with_metadata(resp, response_metadata) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = storage_batch_operations.ListJobsResponse.to_json(response) except: @@ -1796,7 +1848,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1840,7 +1896,11 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1943,7 +2003,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1987,7 +2051,11 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2088,7 +2156,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2210,7 +2282,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2334,7 +2410,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2378,7 +2458,11 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2481,7 +2565,11 @@ def __call__(self, rest_numeric_enums=False, ) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2525,7 +2613,11 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG): # pragma: NO COVER + if ( + CLIENT_LOGGING_SUPPORTED + and _LOGGER.isEnabledFor(logging.DEBUG) + and _LOGGER.hasHandlers() + ): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py index 522152f1acbc..3aa585a949c9 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py @@ -8798,3 +8798,94 @@ def test_storage_batch_operations_base_transport_wrap_async_method_older_api_cor assert "client_options" not in kwargs assert "method_name" not in kwargs assert "is_streaming" not in kwargs + + +def test_storage_batch_operations_grpc_logging_interceptor_requires_handlers(monkeypatch): + std_logging = transports.grpc.std_logging + logger = std_logging.getLogger("test_no_handlers_storage_batch_operations_sync") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc, "_LOGGER", logger) + + interceptor = transports.grpc._LoggingClientInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + response = mock.MagicMock() + response.result.side_effect = AssertionError("result() should not be called without handlers") + continuation = mock.MagicMock(return_value=response) + + out = interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is response + response.result.assert_not_called() + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + logger.addHandler(_ListHandler()) + try: + response.result.side_effect = None + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is response + assert len(records) == 2 + finally: + logger.handlers = [] + + +@pytest.mark.asyncio +async def test_storage_batch_operations_grpc_aio_logging_interceptor_requires_handlers( + monkeypatch, +): + std_logging = transports.grpc_asyncio.std_logging + logger = std_logging.getLogger("test_no_handlers_storage_batch_operations_async") + logger.handlers = [] + logger.setLevel(std_logging.DEBUG) + logger.propagate = False + + monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) + monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) + + interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() + call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) + + class _NoAwaitResponse: + def __await__(self): + raise AssertionError("response should not be awaited without handlers") + + sentinel = _NoAwaitResponse() + continuation = AsyncMock(return_value=sentinel) + + out = await interceptor.intercept_unary_unary(continuation, call_details, object()) + assert out is sentinel + + records = [] + + class _ListHandler(std_logging.Handler): + def emit(self, record): + records.append(record) + + class _AwaitableResponse: + async def trailing_metadata(self): + return () + + def __await__(self): + async def _coro(): + return "ok" + + return _coro().__await__() + + logger.addHandler(_ListHandler()) + try: + aio_response = _AwaitableResponse() + continuation = AsyncMock(return_value=aio_response) + out = await interceptor.intercept_unary_unary(continuation, call_details, "req") + assert out is aio_response + assert len(records) == 2 + finally: + logger.handlers = [] From 57f3c1efcc1a0795893a0d3a36740adc9732103b Mon Sep 17 00:00:00 2001 From: Daniel Sanche Date: Thu, 12 Nov 2026 20:49:10 -0700 Subject: [PATCH 3/4] use macro for logging --- .../%sub/services/%service/_shared_macros.j2 | 23 +- .../%sub/services/%service/async_client.py.j2 | 6 +- .../%sub/services/%service/client.py.j2 | 6 +- .../services/%service/transports/rest.py.j2 | 6 +- .../%service/transports/rest_asyncio.py.j2 | 6 +- .../services/asset_service/async_client.py | 6 +- .../asset_v1/services/asset_service/client.py | 6 +- .../services/asset_service/transports/grpc.py | 6 +- .../asset_service/transports/grpc_asyncio.py | 6 +- .../services/asset_service/transports/rest.py | 276 ++------- .../services/iam_credentials/async_client.py | 6 +- .../services/iam_credentials/client.py | 6 +- .../iam_credentials/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../iam_credentials/transports/rest.py | 48 +- .../services/eventarc/async_client.py | 6 +- .../eventarc_v1/services/eventarc/client.py | 6 +- .../services/eventarc/transports/grpc.py | 6 +- .../eventarc/transports/grpc_asyncio.py | 6 +- .../services/eventarc/transports/rest.py | 564 +++--------------- .../config_service_v2/async_client.py | 6 +- .../services/config_service_v2/client.py | 6 +- .../config_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../logging_service_v2/async_client.py | 6 +- .../services/logging_service_v2/client.py | 6 +- .../logging_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../metrics_service_v2/async_client.py | 6 +- .../services/metrics_service_v2/client.py | 6 +- .../metrics_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../config_service_v2/async_client.py | 6 +- .../services/config_service_v2/client.py | 6 +- .../config_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../logging_service_v2/async_client.py | 6 +- .../services/logging_service_v2/client.py | 6 +- .../logging_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../metrics_service_v2/async_client.py | 6 +- .../services/metrics_service_v2/client.py | 6 +- .../metrics_service_v2/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../services/cloud_redis/async_client.py | 6 +- .../redis_v1/services/cloud_redis/client.py | 6 +- .../services/cloud_redis/transports/grpc.py | 6 +- .../cloud_redis/transports/grpc_asyncio.py | 6 +- .../services/cloud_redis/transports/rest.py | 204 ++----- .../cloud_redis/transports/rest_asyncio.py | 204 ++----- .../services/cloud_redis/async_client.py | 6 +- .../redis_v1/services/cloud_redis/client.py | 6 +- .../services/cloud_redis/transports/grpc.py | 6 +- .../cloud_redis/transports/grpc_asyncio.py | 6 +- .../services/cloud_redis/transports/rest.py | 132 +--- .../cloud_redis/transports/rest_asyncio.py | 132 +--- .../services/echo/async_client.py | 6 +- .../showcase_v1beta1/services/echo/client.py | 6 +- .../services/echo/transports/grpc.py | 6 +- .../services/echo/transports/grpc_asyncio.py | 6 +- .../services/echo/transports/rest.py | 204 ++----- .../services/identity/async_client.py | 6 +- .../services/identity/client.py | 6 +- .../services/identity/transports/grpc.py | 6 +- .../identity/transports/grpc_asyncio.py | 6 +- .../services/identity/transports/rest.py | 150 +---- .../services/messaging/async_client.py | 6 +- .../services/messaging/client.py | 6 +- .../services/messaging/transports/grpc.py | 6 +- .../messaging/transports/grpc_asyncio.py | 6 +- .../services/messaging/transports/rest.py | 228 ++----- .../resumable_upload_service/async_client.py | 6 +- .../resumable_upload_service/client.py | 6 +- .../transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../transports/rest.py | 96 +-- .../services/sequence_service/async_client.py | 6 +- .../services/sequence_service/client.py | 6 +- .../sequence_service/transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../sequence_service/transports/rest.py | 162 +---- .../services/testing/async_client.py | 6 +- .../services/testing/client.py | 6 +- .../services/testing/transports/grpc.py | 6 +- .../testing/transports/grpc_asyncio.py | 6 +- .../services/testing/transports/rest.py | 180 +----- .../storage_batch_operations/async_client.py | 6 +- .../storage_batch_operations/client.py | 6 +- .../transports/grpc.py | 6 +- .../transports/grpc_asyncio.py | 6 +- .../transports/rest.py | 138 +---- 91 files changed, 537 insertions(+), 2660 deletions(-) diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 index b9ed78138ce7..7b677005fc5b 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/_shared_macros.j2 @@ -226,11 +226,7 @@ def _get_http_options(): rest_numeric_enums={{ rest_numeric_enums }}, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if {{ debug_logging_enabled("logging") }}: # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -354,12 +350,13 @@ return {{ client_output_ident }}( {%- endmacro %} +{% macro debug_logging_enabled(logging_expr="std_logging") -%} +CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor({{ logging_expr }}.DEBUG) and _LOGGER.hasHandlers() +{%- endmacro %} + + {% macro unary_request_interceptor_common(service) %} - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = {{ debug_logging_enabled() }} if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): @@ -642,11 +639,7 @@ class {{ name|make_private }}(_Base{{ service.name }}RestTransport._Base{{name}} resp = {{ sig.response_type }}() resp = json_format.Parse(content, resp) resp = {{ await_prefix }}self._interceptor.post_{{ name|snake_case }}(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if {{ debug_logging_enabled("logging") }}: # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 index c7970699d4f7..aed5b46b814f 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/async_client.py.j2 @@ -264,11 +264,7 @@ class {{ service.async_client_name }}: ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if {{ shared_macros.debug_logging_enabled() }}: # pragma: NO COVER _LOGGER.debug( "Created client `{{ service.meta.address.proto_package_versioned }}.{{ service.async_client_name }}`.", extra = { diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 index 0ff0fc4afc73..50935a058cf2 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/client.py.j2 @@ -567,11 +567,7 @@ class {{ service.client_name }}(metaclass={{ service.client_name }}Meta): self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if {{ shared_macros.debug_logging_enabled() }}: # pragma: NO COVER _LOGGER.debug( "Created client `{{ service.meta.address.proto_package_versioned }}.{{ service.client_name }}`.", extra = { diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 index 0d2f248976d9..d955e11edd40 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest.py.j2 @@ -303,11 +303,7 @@ class {{service.name}}RestTransport(_Base{{ service.name }}RestTransport): resp = self._interceptor.post_{{ method.name|snake_case }}(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_{{ method.name|snake_case }}_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if {{ shared_macros.debug_logging_enabled("logging") }}: # pragma: NO COVER {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2389): #} {# Depending how we want to log (a) receiving a streaming response vs (b) exposing the next streamed item to the user, we could possibly want to log something here #} {# (a) should always happen in api-core #} diff --git a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 index d4ca833c99c6..96ae635a2be9 100644 --- a/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 +++ b/packages/gapic-generator/gapic/templates/%namespace/%name_%version/%sub/services/%service/transports/rest_asyncio.py.j2 @@ -257,11 +257,7 @@ class Async{{service.name}}RestTransport(_Base{{ service.name }}RestTransport): resp = await self._interceptor.post_{{ method.name|snake_case }}(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_{{ method.name|snake_case }}_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if {{ shared_macros.debug_logging_enabled("logging") }}: # pragma: NO COVER {# TODO(https://github.com/googleapis/gapic-generator-python/issues/2389): #} {# Depending how we want to log (a) receiving a streaming response vs (b) exposing the next streamed item to the user, we could possibly want to log something here #} {# (a) should always happen in api-core #} diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py index 0d6bbd6ff47e..ca7e2ceb1a83 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/async_client.py @@ -262,11 +262,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.asset_v1.AssetServiceAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py index c8b1f8acadac..6b71f606993b 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/client.py @@ -574,11 +574,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.asset_v1.AssetServiceClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py index b1c77b6643ee..8b58f448f631 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc.py @@ -59,11 +59,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py index fe675f8f0a3f..ca9670eb0f01 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/grpc_asyncio.py @@ -59,11 +59,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py index 7c53899191a7..8f903c742cec 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/google/cloud/asset_v1/services/asset_service/transports/rest.py @@ -1272,11 +1272,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1324,11 +1320,7 @@ def __call__(self, resp = self._interceptor.post_analyze_iam_policy(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_iam_policy_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.AnalyzeIamPolicyResponse.to_json(response) except: @@ -1433,11 +1425,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1484,11 +1472,7 @@ def __call__(self, resp = self._interceptor.post_analyze_iam_policy_longrunning(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_iam_policy_longrunning_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1590,11 +1574,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1642,11 +1622,7 @@ def __call__(self, resp = self._interceptor.post_analyze_move(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_move_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.AnalyzeMoveResponse.to_json(response) except: @@ -1748,11 +1724,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1800,11 +1772,7 @@ def __call__(self, resp = self._interceptor.post_analyze_org_policies(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_org_policies_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.AnalyzeOrgPoliciesResponse.to_json(response) except: @@ -1907,11 +1875,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1959,11 +1923,7 @@ def __call__(self, resp = self._interceptor.post_analyze_org_policy_governed_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_org_policy_governed_assets_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.AnalyzeOrgPolicyGovernedAssetsResponse.to_json(response) except: @@ -2066,11 +2026,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2118,11 +2074,7 @@ def __call__(self, resp = self._interceptor.post_analyze_org_policy_governed_containers(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_analyze_org_policy_governed_containers_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.AnalyzeOrgPolicyGovernedContainersResponse.to_json(response) except: @@ -2221,11 +2173,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2273,11 +2221,7 @@ def __call__(self, resp = self._interceptor.post_batch_get_assets_history(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_batch_get_assets_history_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.BatchGetAssetsHistoryResponse.to_json(response) except: @@ -2380,11 +2324,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2432,11 +2372,7 @@ def __call__(self, resp = self._interceptor.post_batch_get_effective_iam_policies(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_batch_get_effective_iam_policies_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.BatchGetEffectiveIamPoliciesResponse.to_json(response) except: @@ -2544,11 +2480,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2597,11 +2529,7 @@ def __call__(self, resp = self._interceptor.post_create_feed(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_feed_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.Feed.to_json(response) except: @@ -2703,11 +2631,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2756,11 +2680,7 @@ def __call__(self, resp = self._interceptor.post_create_saved_query(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_saved_query_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.SavedQuery.to_json(response) except: @@ -2855,11 +2775,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2973,11 +2889,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3099,11 +3011,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3150,11 +3058,7 @@ def __call__(self, resp = self._interceptor.post_export_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_export_assets_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3261,11 +3165,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3313,11 +3213,7 @@ def __call__(self, resp = self._interceptor.post_get_feed(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_feed_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.Feed.to_json(response) except: @@ -3418,11 +3314,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3470,11 +3362,7 @@ def __call__(self, resp = self._interceptor.post_get_saved_query(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_saved_query_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.SavedQuery.to_json(response) except: @@ -3573,11 +3461,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3625,11 +3509,7 @@ def __call__(self, resp = self._interceptor.post_list_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_assets_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.ListAssetsResponse.to_json(response) except: @@ -3728,11 +3608,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3780,11 +3656,7 @@ def __call__(self, resp = self._interceptor.post_list_feeds(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_feeds_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.ListFeedsResponse.to_json(response) except: @@ -3883,11 +3755,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3935,11 +3803,7 @@ def __call__(self, resp = self._interceptor.post_list_saved_queries(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_saved_queries_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.ListSavedQueriesResponse.to_json(response) except: @@ -4039,11 +3903,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4092,11 +3952,7 @@ def __call__(self, resp = self._interceptor.post_query_assets(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_query_assets_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.QueryAssetsResponse.to_json(response) except: @@ -4195,11 +4051,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4247,11 +4099,7 @@ def __call__(self, resp = self._interceptor.post_search_all_iam_policies(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_search_all_iam_policies_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.SearchAllIamPoliciesResponse.to_json(response) except: @@ -4350,11 +4198,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4402,11 +4246,7 @@ def __call__(self, resp = self._interceptor.post_search_all_resources(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_search_all_resources_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.SearchAllResourcesResponse.to_json(response) except: @@ -4514,11 +4354,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4567,11 +4403,7 @@ def __call__(self, resp = self._interceptor.post_update_feed(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_feed_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.Feed.to_json(response) except: @@ -4673,11 +4505,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4726,11 +4554,7 @@ def __call__(self, resp = self._interceptor.post_update_saved_query(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_saved_query_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = asset_service.SavedQuery.to_json(response) except: @@ -5017,11 +4841,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5065,11 +4885,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py index 565c096ed453..cd620522e45b 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/async_client.py @@ -253,11 +253,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.iam.credentials_v1.IAMCredentialsAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py index 6f1f38e6c9a6..928f17d88769 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/client.py @@ -511,11 +511,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.iam.credentials_v1.IAMCredentialsClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py index a1f950cdc79b..3441ff5d00be 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc.py @@ -56,11 +56,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py index d75f12794d61..da8f4c6bf47d 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/grpc_asyncio.py @@ -56,11 +56,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py index 594edfcbb7de..e730b0c0aa95 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/google/iam/credentials_v1/services/iam_credentials/transports/rest.py @@ -451,11 +451,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -504,11 +500,7 @@ def __call__(self, resp = self._interceptor.post_generate_access_token(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_generate_access_token_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = common.GenerateAccessTokenResponse.to_json(response) except: @@ -608,11 +600,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -661,11 +649,7 @@ def __call__(self, resp = self._interceptor.post_generate_id_token(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_generate_id_token_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = common.GenerateIdTokenResponse.to_json(response) except: @@ -765,11 +749,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -818,11 +798,7 @@ def __call__(self, resp = self._interceptor.post_sign_blob(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_sign_blob_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = common.SignBlobResponse.to_json(response) except: @@ -922,11 +898,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -975,11 +947,7 @@ def __call__(self, resp = self._interceptor.post_sign_jwt(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_sign_jwt_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = common.SignJwtResponse.to_json(response) except: diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py index 18ba3ecd72d1..679ebf88f3c2 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/async_client.py @@ -301,11 +301,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.eventarc_v1.EventarcAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py index ba46c0708c8d..8aec48e21e2b 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/client.py @@ -694,11 +694,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.eventarc_v1.EventarcClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py index 8fa8e146cada..56bf254d7c4a 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc.py @@ -71,11 +71,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py index fb5d28e0d8f1..17e8a7d1e54a 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/grpc_asyncio.py @@ -71,11 +71,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py index 6f6b1de8baa6..96caeb620d7d 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/google/cloud/eventarc_v1/services/eventarc/transports/rest.py @@ -2243,11 +2243,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2294,11 +2290,7 @@ def __call__(self, resp = self._interceptor.post_create_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_channel_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2402,11 +2394,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2453,11 +2441,7 @@ def __call__(self, resp = self._interceptor.post_create_channel_connection(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_channel_connection_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2561,11 +2545,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2612,11 +2592,7 @@ def __call__(self, resp = self._interceptor.post_create_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_enrollment_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2720,11 +2696,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2771,11 +2743,7 @@ def __call__(self, resp = self._interceptor.post_create_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_google_api_source_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2879,11 +2847,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2930,11 +2894,7 @@ def __call__(self, resp = self._interceptor.post_create_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_message_bus_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3038,11 +2998,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3089,11 +3045,7 @@ def __call__(self, resp = self._interceptor.post_create_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_pipeline_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3197,11 +3149,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3248,11 +3196,7 @@ def __call__(self, resp = self._interceptor.post_create_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_trigger_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3355,11 +3299,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3405,11 +3345,7 @@ def __call__(self, resp = self._interceptor.post_delete_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_channel_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3512,11 +3448,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3562,11 +3494,7 @@ def __call__(self, resp = self._interceptor.post_delete_channel_connection(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_channel_connection_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3669,11 +3597,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3719,11 +3643,7 @@ def __call__(self, resp = self._interceptor.post_delete_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_enrollment_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3826,11 +3746,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3876,11 +3792,7 @@ def __call__(self, resp = self._interceptor.post_delete_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_google_api_source_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3983,11 +3895,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4033,11 +3941,7 @@ def __call__(self, resp = self._interceptor.post_delete_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_message_bus_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -4140,11 +4044,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4190,11 +4090,7 @@ def __call__(self, resp = self._interceptor.post_delete_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_pipeline_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -4297,11 +4193,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4347,11 +4239,7 @@ def __call__(self, resp = self._interceptor.post_delete_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_trigger_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -4459,11 +4347,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4511,11 +4395,7 @@ def __call__(self, resp = self._interceptor.post_get_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_channel_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = channel.Channel.to_json(response) except: @@ -4622,11 +4502,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4674,11 +4550,7 @@ def __call__(self, resp = self._interceptor.post_get_channel_connection(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_channel_connection_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = channel_connection.ChannelConnection.to_json(response) except: @@ -4784,11 +4656,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4836,11 +4704,7 @@ def __call__(self, resp = self._interceptor.post_get_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_enrollment_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = enrollment.Enrollment.to_json(response) except: @@ -4943,11 +4807,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4995,11 +4855,7 @@ def __call__(self, resp = self._interceptor.post_get_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_google_api_source_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = google_api_source.GoogleApiSource.to_json(response) except: @@ -5107,11 +4963,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5159,11 +5011,7 @@ def __call__(self, resp = self._interceptor.post_get_google_channel_config(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_google_channel_config_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = google_channel_config.GoogleChannelConfig.to_json(response) except: @@ -5271,11 +5119,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5323,11 +5167,7 @@ def __call__(self, resp = self._interceptor.post_get_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_message_bus_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = message_bus.MessageBus.to_json(response) except: @@ -5429,11 +5269,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5481,11 +5317,7 @@ def __call__(self, resp = self._interceptor.post_get_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_pipeline_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = pipeline.Pipeline.to_json(response) except: @@ -5587,11 +5419,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5639,11 +5467,7 @@ def __call__(self, resp = self._interceptor.post_get_provider(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_provider_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = discovery.Provider.to_json(response) except: @@ -5745,11 +5569,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5797,11 +5617,7 @@ def __call__(self, resp = self._interceptor.post_get_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_trigger_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = trigger.Trigger.to_json(response) except: @@ -5903,11 +5719,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -5955,11 +5767,7 @@ def __call__(self, resp = self._interceptor.post_list_channel_connections(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_channel_connections_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListChannelConnectionsResponse.to_json(response) except: @@ -6059,11 +5867,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6111,11 +5915,7 @@ def __call__(self, resp = self._interceptor.post_list_channels(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_channels_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListChannelsResponse.to_json(response) except: @@ -6215,11 +6015,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6267,11 +6063,7 @@ def __call__(self, resp = self._interceptor.post_list_enrollments(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_enrollments_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListEnrollmentsResponse.to_json(response) except: @@ -6373,11 +6165,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6425,11 +6213,7 @@ def __call__(self, resp = self._interceptor.post_list_google_api_sources(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_google_api_sources_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListGoogleApiSourcesResponse.to_json(response) except: @@ -6532,11 +6316,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6584,11 +6364,7 @@ def __call__(self, resp = self._interceptor.post_list_message_bus_enrollments(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_message_bus_enrollments_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListMessageBusEnrollmentsResponse.to_json(response) except: @@ -6690,11 +6466,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6742,11 +6514,7 @@ def __call__(self, resp = self._interceptor.post_list_message_buses(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_message_buses_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListMessageBusesResponse.to_json(response) except: @@ -6848,11 +6616,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -6900,11 +6664,7 @@ def __call__(self, resp = self._interceptor.post_list_pipelines(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_pipelines_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListPipelinesResponse.to_json(response) except: @@ -7004,11 +6764,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7056,11 +6812,7 @@ def __call__(self, resp = self._interceptor.post_list_providers(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_providers_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListProvidersResponse.to_json(response) except: @@ -7160,11 +6912,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7212,11 +6960,7 @@ def __call__(self, resp = self._interceptor.post_list_triggers(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_triggers_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = eventarc.ListTriggersResponse.to_json(response) except: @@ -7320,11 +7064,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7371,11 +7111,7 @@ def __call__(self, resp = self._interceptor.post_update_channel(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_channel_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7479,11 +7215,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7530,11 +7262,7 @@ def __call__(self, resp = self._interceptor.post_update_enrollment(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_enrollment_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7638,11 +7366,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7689,11 +7413,7 @@ def __call__(self, resp = self._interceptor.post_update_google_api_source(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_google_api_source_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -7803,11 +7523,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -7856,11 +7572,7 @@ def __call__(self, resp = self._interceptor.post_update_google_channel_config(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_google_channel_config_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gce_google_channel_config.GoogleChannelConfig.to_json(response) except: @@ -7964,11 +7676,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8015,11 +7723,7 @@ def __call__(self, resp = self._interceptor.post_update_message_bus(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_message_bus_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8123,11 +7827,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8174,11 +7874,7 @@ def __call__(self, resp = self._interceptor.post_update_pipeline(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_pipeline_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8282,11 +7978,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8333,11 +8025,7 @@ def __call__(self, resp = self._interceptor.post_update_trigger(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_trigger_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8752,11 +8440,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8800,11 +8484,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -8907,11 +8587,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -8955,11 +8631,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9062,11 +8734,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9110,11 +8778,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9218,11 +8882,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9267,11 +8927,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9375,11 +9031,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9424,11 +9076,7 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9529,11 +9177,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9655,11 +9299,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9783,11 +9423,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9831,11 +9467,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -9938,11 +9570,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -9986,11 +9614,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py index d234a72f9cbd..6b79e385cd66 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/async_client.py @@ -257,11 +257,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.ConfigServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py index 2c1def209bfe..291a221299d8 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/client.py @@ -567,11 +567,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.ConfigServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py index c9e7b0e86b07..cc3843de9d85 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py @@ -59,11 +59,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py index f35e492aef60..1d0cf5ea9497 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py @@ -59,11 +59,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py index e932609563b6..9b4af56f7b04 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/async_client.py @@ -242,11 +242,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py index 3b0c5e592493..32f9e348046c 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/client.py @@ -498,11 +498,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py index 7337914e53bf..efeb097689de 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py @@ -58,11 +58,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py index 8ae650a6bfa3..6951a7199814 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py @@ -58,11 +58,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py index f4e707c16d1f..cd5a88ea7472 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/async_client.py @@ -243,11 +243,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.MetricsServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py index b9ee5ec71ff3..81e9084a0871 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/client.py @@ -499,11 +499,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.MetricsServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py index 4b99ea32e0f1..d721ab958734 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py @@ -58,11 +58,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py index e937fe038658..3106a8fa7d4a 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py @@ -58,11 +58,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py index b9491291f5a0..7cfa3669d0a8 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/async_client.py @@ -257,11 +257,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseConfigServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py index b5383105a406..d3e4783699ab 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/client.py @@ -567,11 +567,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseConfigServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py index c9e7b0e86b07..cc3843de9d85 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc.py @@ -59,11 +59,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py index f35e492aef60..1d0cf5ea9497 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/config_service_v2/transports/grpc_asyncio.py @@ -59,11 +59,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py index e932609563b6..9b4af56f7b04 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/async_client.py @@ -242,11 +242,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py index 3b0c5e592493..32f9e348046c 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/client.py @@ -498,11 +498,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.LoggingServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py index 7337914e53bf..efeb097689de 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc.py @@ -58,11 +58,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py index 8ae650a6bfa3..6951a7199814 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/logging_service_v2/transports/grpc_asyncio.py @@ -58,11 +58,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py index c794492b4ae3..73a44cba5699 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/async_client.py @@ -243,11 +243,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseMetricsServiceV2AsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py index f4f94dbc0282..90c496112e86 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/client.py @@ -499,11 +499,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.logging_v2.BaseMetricsServiceV2Client`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py index 4b99ea32e0f1..d721ab958734 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc.py @@ -58,11 +58,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py index e937fe038658..3106a8fa7d4a 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/google/cloud/logging_v2/services/metrics_service_v2/transports/grpc_asyncio.py @@ -58,11 +58,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py index d93b6dc23d65..3e515ef07552 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/async_client.py @@ -270,11 +270,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py index 8912c2d6335c..3b22e6fd38d9 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/client.py @@ -565,11 +565,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py index be3b545b460f..07d87c53656d 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py @@ -59,11 +59,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py index 489c0e2a0cdd..7181fcd2dd7d 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py @@ -59,11 +59,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 03e018aaca7d..0fa1acf6805e 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -981,11 +981,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1032,11 +1028,7 @@ def __call__(self, resp = self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1139,11 +1131,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1189,11 +1177,7 @@ def __call__(self, resp = self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1297,11 +1281,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1348,11 +1328,7 @@ def __call__(self, resp = self._interceptor.post_export_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_export_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1456,11 +1432,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1507,11 +1479,7 @@ def __call__(self, resp = self._interceptor.post_failover_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_failover_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1611,11 +1579,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1663,11 +1627,7 @@ def __call__(self, resp = self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1767,11 +1727,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1819,11 +1775,7 @@ def __call__(self, resp = self._interceptor.post_get_instance_auth_string(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_instance_auth_string_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.InstanceAuthString.to_json(response) except: @@ -1927,11 +1879,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1978,11 +1926,7 @@ def __call__(self, resp = self._interceptor.post_import_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_import_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2084,11 +2028,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2136,11 +2076,7 @@ def __call__(self, resp = self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -2244,11 +2180,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2295,11 +2227,7 @@ def __call__(self, resp = self._interceptor.post_reschedule_maintenance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_reschedule_maintenance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2403,11 +2331,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2454,11 +2378,7 @@ def __call__(self, resp = self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2562,11 +2482,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2613,11 +2529,7 @@ def __call__(self, resp = self._interceptor.post_upgrade_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_upgrade_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2808,11 +2720,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2856,11 +2764,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2963,11 +2867,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3011,11 +2911,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3115,11 +3011,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3240,11 +3132,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3368,11 +3256,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3416,11 +3300,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3523,11 +3403,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3571,11 +3447,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3679,11 +3551,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3728,11 +3596,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_wait_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index 77cd0ec7bfb5..0b52d6fbc103 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -1023,11 +1023,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1080,11 +1076,7 @@ async def __call__(self, resp = await self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1188,11 +1180,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1244,11 +1232,7 @@ async def __call__(self, resp = await self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1353,11 +1337,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1410,11 +1390,7 @@ async def __call__(self, resp = await self._interceptor.post_export_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_export_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1519,11 +1495,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1576,11 +1548,7 @@ async def __call__(self, resp = await self._interceptor.post_failover_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_failover_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1681,11 +1649,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1737,11 +1701,7 @@ async def __call__(self, resp = await self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1842,11 +1802,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1898,11 +1854,7 @@ async def __call__(self, resp = await self._interceptor.post_get_instance_auth_string(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_get_instance_auth_string_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.InstanceAuthString.to_json(response) except: @@ -2007,11 +1959,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2064,11 +2012,7 @@ async def __call__(self, resp = await self._interceptor.post_import_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_import_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2171,11 +2115,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2227,11 +2167,7 @@ async def __call__(self, resp = await self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -2336,11 +2272,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2393,11 +2325,7 @@ async def __call__(self, resp = await self._interceptor.post_reschedule_maintenance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_reschedule_maintenance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2502,11 +2430,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2559,11 +2483,7 @@ async def __call__(self, resp = await self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2668,11 +2588,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2725,11 +2641,7 @@ async def __call__(self, resp = await self._interceptor.post_upgrade_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_upgrade_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2955,11 +2867,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3007,11 +2915,7 @@ async def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3114,11 +3018,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3166,11 +3066,7 @@ async def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3270,11 +3166,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3399,11 +3291,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3531,11 +3419,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3583,11 +3467,7 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3690,11 +3570,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3742,11 +3618,7 @@ async def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3850,11 +3722,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3903,11 +3771,7 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_wait_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py index 8f58ae7a20db..bd023653dd5c 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/async_client.py @@ -270,11 +270,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py index 070d58ffb608..28d4e95aa0a4 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/client.py @@ -565,11 +565,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.redis_v1.CloudRedisClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py index 6c46cd3db868..344ee47567d4 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc.py @@ -59,11 +59,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py index 3f8b31dd269f..a3a5f2d79e9f 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/grpc_asyncio.py @@ -59,11 +59,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py index 410d8dc09ed0..a33851dfd98c 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest.py @@ -717,11 +717,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -768,11 +764,7 @@ def __call__(self, resp = self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -875,11 +867,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -925,11 +913,7 @@ def __call__(self, resp = self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1029,11 +1013,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1081,11 +1061,7 @@ def __call__(self, resp = self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1187,11 +1163,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1239,11 +1211,7 @@ def __call__(self, resp = self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -1347,11 +1315,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1398,11 +1362,7 @@ def __call__(self, resp = self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1545,11 +1505,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1593,11 +1549,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1700,11 +1652,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1748,11 +1696,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1852,11 +1796,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1977,11 +1917,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2105,11 +2041,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2153,11 +2085,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2260,11 +2188,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2308,11 +2232,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2416,11 +2336,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2465,11 +2381,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_wait_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py index 90aa41086acd..98e35969d550 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/google/cloud/redis_v1/services/cloud_redis/transports/rest_asyncio.py @@ -723,11 +723,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -780,11 +776,7 @@ async def __call__(self, resp = await self._interceptor.post_create_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_create_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -888,11 +880,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -944,11 +932,7 @@ async def __call__(self, resp = await self._interceptor.post_delete_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_delete_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1049,11 +1033,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1105,11 +1085,7 @@ async def __call__(self, resp = await self._interceptor.post_get_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_get_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.Instance.to_json(response) except: @@ -1212,11 +1188,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1268,11 +1240,7 @@ async def __call__(self, resp = await self._interceptor.post_list_instances(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_list_instances_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = cloud_redis.ListInstancesResponse.to_json(response) except: @@ -1377,11 +1345,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1434,11 +1398,7 @@ async def __call__(self, resp = await self._interceptor.post_update_instance(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = await self._interceptor.post_update_instance_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1628,11 +1588,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1680,11 +1636,7 @@ async def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1787,11 +1739,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1839,11 +1787,7 @@ async def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1943,11 +1887,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2072,11 +2012,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2204,11 +2140,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2256,11 +2188,7 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2363,11 +2291,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2415,11 +2339,7 @@ async def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2523,11 +2443,7 @@ async def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2576,11 +2492,7 @@ async def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = await self._interceptor.post_wait_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py index 1cfdf707dbd7..6407236400f9 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/async_client.py @@ -259,11 +259,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.EchoAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py index 7a8d78af0f4a..60c87ce61625 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/client.py @@ -508,11 +508,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.EchoClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py index aae0259fefb0..dfe70a72a077 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc.py @@ -61,11 +61,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py index ecbf8a1d8952..9c7106fc8e94 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/grpc_asyncio.py @@ -61,11 +61,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py index 0b87ebae4de4..25372e7e5919 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/echo/transports/rest.py @@ -909,11 +909,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -962,11 +958,7 @@ def __call__(self, resp = self._interceptor.post_block(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_block_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_echo.BlockResponse.to_json(response) except: @@ -1099,11 +1091,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1152,11 +1140,7 @@ def __call__(self, resp = self._interceptor.post_echo(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_echo_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_echo.EchoResponse.to_json(response) except: @@ -1259,11 +1243,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1312,11 +1292,7 @@ def __call__(self, resp = self._interceptor.post_echo_error_details(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_echo_error_details_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_echo.EchoErrorDetailsResponse.to_json(response) except: @@ -1420,11 +1396,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1470,11 +1442,7 @@ def __call__(self, resp = self._interceptor.post_expand(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_expand_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER http_response = { "headers": dict(response.headers), "status": response.status_code, @@ -1573,11 +1541,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1626,11 +1590,7 @@ def __call__(self, resp = self._interceptor.post_fail_echo_with_details(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_fail_echo_with_details_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_echo.FailEchoWithDetailsResponse.to_json(response) except: @@ -1733,11 +1693,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1786,11 +1742,7 @@ def __call__(self, resp = self._interceptor.post_paged_expand(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_paged_expand_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_echo.PagedExpandResponse.to_json(response) except: @@ -1897,11 +1849,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1950,11 +1898,7 @@ def __call__(self, resp = self._interceptor.post_paged_expand_legacy(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_paged_expand_legacy_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_echo.PagedExpandResponse.to_json(response) except: @@ -2056,11 +2000,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2109,11 +2049,7 @@ def __call__(self, resp = self._interceptor.post_paged_expand_legacy_mapped(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_paged_expand_legacy_mapped_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_echo.PagedExpandLegacyMappedResponse.to_json(response) except: @@ -2216,11 +2152,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2267,11 +2199,7 @@ def __call__(self, resp = self._interceptor.post_wait(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_wait_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2462,11 +2390,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2510,11 +2434,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2617,11 +2537,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2665,11 +2581,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2773,11 +2685,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2822,11 +2730,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2929,11 +2833,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2977,11 +2877,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3085,11 +2981,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3134,11 +3026,7 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3241,11 +3129,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3289,11 +3173,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3396,11 +3276,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3444,11 +3320,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3548,11 +3420,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3673,11 +3541,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py index e6ff9173ff73..56ee51ef89df 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/async_client.py @@ -246,11 +246,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.IdentityAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py index d9ea6612f9f2..b24a2c50fcc1 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/client.py @@ -504,11 +504,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.IdentityClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py index ef779d79b77c..649711b5c590 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc.py @@ -61,11 +61,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py index b6e8446a3847..12dd38691392 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/grpc_asyncio.py @@ -61,11 +61,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py index 4814cd582717..f4a9399c9f26 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/identity/transports/rest.py @@ -646,11 +646,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -699,11 +695,7 @@ def __call__(self, resp = self._interceptor.post_create_user(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_user_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = identity.User.to_json(response) except: @@ -800,11 +792,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -924,11 +912,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -976,11 +960,7 @@ def __call__(self, resp = self._interceptor.post_get_user(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_user_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = identity.User.to_json(response) except: @@ -1084,11 +1064,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1136,11 +1112,7 @@ def __call__(self, resp = self._interceptor.post_list_users(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_users_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = identity.ListUsersResponse.to_json(response) except: @@ -1242,11 +1214,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1295,11 +1263,7 @@ def __call__(self, resp = self._interceptor.post_update_user(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_user_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = identity.User.to_json(response) except: @@ -1442,11 +1406,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1490,11 +1450,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1597,11 +1553,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1645,11 +1597,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1753,11 +1701,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1802,11 +1746,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1909,11 +1849,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1957,11 +1893,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2065,11 +1997,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2114,11 +2042,7 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2221,11 +2145,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2269,11 +2189,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2376,11 +2292,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2424,11 +2336,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2528,11 +2436,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2653,11 +2557,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py index dd80082e1304..623ea3b4b344 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/async_client.py @@ -256,11 +256,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.MessagingAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py index 52e2c0eeb6bc..4a349f41ce78 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/client.py @@ -532,11 +532,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.MessagingClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py index d2ec94705164..8eba92dcb810 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc.py @@ -62,11 +62,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py index da8a4409be2e..0e4820001b85 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/grpc_asyncio.py @@ -62,11 +62,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py index cbff605cf115..cc15a71f9d0f 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/messaging/transports/rest.py @@ -992,11 +992,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1045,11 +1041,7 @@ def __call__(self, resp = self._interceptor.post_create_blurb(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_blurb_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.Blurb.to_json(response) except: @@ -1151,11 +1143,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1204,11 +1192,7 @@ def __call__(self, resp = self._interceptor.post_create_room(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_room_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.Room.to_json(response) except: @@ -1305,11 +1289,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1425,11 +1405,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1552,11 +1528,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1604,11 +1576,7 @@ def __call__(self, resp = self._interceptor.post_get_blurb(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_blurb_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.Blurb.to_json(response) except: @@ -1709,11 +1677,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1761,11 +1725,7 @@ def __call__(self, resp = self._interceptor.post_get_room(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_room_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.Room.to_json(response) except: @@ -1869,11 +1829,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1921,11 +1877,7 @@ def __call__(self, resp = self._interceptor.post_list_blurbs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_blurbs_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.ListBlurbsResponse.to_json(response) except: @@ -2029,11 +1981,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2081,11 +2029,7 @@ def __call__(self, resp = self._interceptor.post_list_rooms(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_rooms_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.ListRoomsResponse.to_json(response) except: @@ -2190,11 +2134,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2241,11 +2181,7 @@ def __call__(self, resp = self._interceptor.post_search_blurbs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_search_blurbs_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2364,11 +2300,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2414,11 +2346,7 @@ def __call__(self, resp = self._interceptor.post_stream_blurbs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_stream_blurbs_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER http_response = { "headers": dict(response.headers), "status": response.status_code, @@ -2518,11 +2446,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2571,11 +2495,7 @@ def __call__(self, resp = self._interceptor.post_update_blurb(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_blurb_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.Blurb.to_json(response) except: @@ -2677,11 +2597,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2730,11 +2646,7 @@ def __call__(self, resp = self._interceptor.post_update_room(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_update_room_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = messaging.Room.to_json(response) except: @@ -2949,11 +2861,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2997,11 +2905,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3104,11 +3008,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3152,11 +3052,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3260,11 +3156,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3309,11 +3201,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3416,11 +3304,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3464,11 +3348,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3572,11 +3452,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3621,11 +3497,7 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3728,11 +3600,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3776,11 +3644,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3883,11 +3747,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3931,11 +3791,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -4035,11 +3891,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -4160,11 +4012,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py index 7d84d7a23a0f..329e9adf1ecd 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/async_client.py @@ -246,11 +246,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.ResumableUploadServiceAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py index 88113b83b80d..2ee1fcd8f870 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/client.py @@ -495,11 +495,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.ResumableUploadServiceClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py index 2a6dae3b16a8..3ed878d9cdaa 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc.py @@ -63,11 +63,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py index 93bd953d8984..c4e54e78329b 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/grpc_asyncio.py @@ -66,11 +66,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py index 873d45068d4e..f5be1f29829d 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/resumable_upload_service/transports/rest.py @@ -555,11 +555,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -603,11 +599,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -710,11 +702,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -758,11 +746,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -866,11 +850,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -915,11 +895,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1022,11 +998,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1070,11 +1042,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1178,11 +1146,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1227,11 +1191,7 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1334,11 +1294,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1382,11 +1338,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1489,11 +1441,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1537,11 +1485,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1641,11 +1585,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1766,11 +1706,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py index 426dbd42cadf..80ffa479a8a2 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/async_client.py @@ -254,11 +254,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.SequenceServiceAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py index 3afb1ab616db..083552fd2dae 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/client.py @@ -539,11 +539,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.SequenceServiceClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py index efd355db388f..a0295709dc4e 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc.py @@ -62,11 +62,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py index d4b8baa3f0f5..0c4e51fb42cb 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/grpc_asyncio.py @@ -62,11 +62,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py index c61709776cb0..1d48cc3919ab 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/sequence_service/transports/rest.py @@ -688,11 +688,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -817,11 +813,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -867,11 +859,7 @@ def __call__(self, resp = self._interceptor.post_attempt_streaming_sequence(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_attempt_streaming_sequence_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER http_response = { "headers": dict(response.headers), "status": response.status_code, @@ -970,11 +958,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1023,11 +1007,7 @@ def __call__(self, resp = self._interceptor.post_create_sequence(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_sequence_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = gs_sequence.Sequence.to_json(response) except: @@ -1132,11 +1112,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1185,11 +1161,7 @@ def __call__(self, resp = self._interceptor.post_create_streaming_sequence(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_streaming_sequence_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = sequence.StreamingSequence.to_json(response) except: @@ -1290,11 +1262,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1342,11 +1310,7 @@ def __call__(self, resp = self._interceptor.post_get_sequence_report(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_sequence_report_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = sequence.SequenceReport.to_json(response) except: @@ -1448,11 +1412,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1500,11 +1460,7 @@ def __call__(self, resp = self._interceptor.post_get_streaming_sequence_report(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_streaming_sequence_report_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = sequence.StreamingSequenceReport.to_json(response) except: @@ -1655,11 +1611,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1703,11 +1655,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1810,11 +1758,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1858,11 +1802,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1966,11 +1906,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2015,11 +1951,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2122,11 +2054,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2170,11 +2098,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2278,11 +2202,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2327,11 +2247,7 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2434,11 +2350,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2482,11 +2394,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2589,11 +2497,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2637,11 +2541,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2741,11 +2641,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2866,11 +2762,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py index b16875ddec1e..b9ece4447129 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/async_client.py @@ -256,11 +256,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.TestingAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py index 652cae3bb194..efb2ba606e33 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/client.py @@ -532,11 +532,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.showcase_v1beta1.TestingClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py index afbaabe9c9a6..e4118c862dd5 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc.py @@ -61,11 +61,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py index 83c5188c61e9..bc98e78f5e4e 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/grpc_asyncio.py @@ -61,11 +61,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py index 8a0ce641e7b8..9de023f1e9a6 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/google/showcase_v1beta1/services/testing/transports/rest.py @@ -758,11 +758,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -811,11 +807,7 @@ def __call__(self, resp = self._interceptor.post_create_session(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_session_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = testing.Session.to_json(response) except: @@ -910,11 +902,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1028,11 +1016,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1158,11 +1142,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1210,11 +1190,7 @@ def __call__(self, resp = self._interceptor.post_get_session(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_session_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = testing.Session.to_json(response) except: @@ -1314,11 +1290,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1366,11 +1338,7 @@ def __call__(self, resp = self._interceptor.post_list_sessions(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_sessions_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = testing.ListSessionsResponse.to_json(response) except: @@ -1471,11 +1439,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1523,11 +1487,7 @@ def __call__(self, resp = self._interceptor.post_list_tests(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_tests_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = testing.ListTestsResponse.to_json(response) except: @@ -1629,11 +1589,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1681,11 +1637,7 @@ def __call__(self, resp = self._interceptor.post_report_session(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_report_session_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = testing.ReportSessionResponse.to_json(response) except: @@ -1784,11 +1736,7 @@ def __call__(self, rest_numeric_enums=True, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1836,11 +1784,7 @@ def __call__(self, resp = self._interceptor.post_verify_test(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_verify_test_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = testing.VerifyTestResponse.to_json(response) except: @@ -2007,11 +1951,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2055,11 +1995,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2162,11 +2098,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2210,11 +2142,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2318,11 +2246,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2367,11 +2291,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_set_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2474,11 +2394,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2522,11 +2438,7 @@ def __call__(self, resp = policy_pb2.Policy() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_iam_policy(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2630,11 +2542,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2679,11 +2587,7 @@ def __call__(self, resp = iam_policy_pb2.TestIamPermissionsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_test_iam_permissions(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2786,11 +2690,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2834,11 +2734,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2941,11 +2837,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2989,11 +2881,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -3093,11 +2981,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -3218,11 +3102,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py index c1a9df8b95bb..6ad25b7cedc2 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/async_client.py @@ -259,11 +259,7 @@ def __init__(self, *, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.storagebatchoperations_v1.StorageBatchOperationsAsyncClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py index dee5b9fa1009..d5ceb7a69132 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/client.py @@ -535,11 +535,7 @@ def __init__(self, *, self._transport = transport_init(**transport_kwargs) if "async" not in str(self._transport): - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER _LOGGER.debug( "Created client `google.cloud.storagebatchoperations_v1.StorageBatchOperationsClient`.", extra = { diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py index 9cc9aeb05dd9..13ad98db94c6 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc.py @@ -61,11 +61,7 @@ class _LoggingClientInterceptor(grpc.UnaryUnaryClientInterceptor): # pragma: NO COVER def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py index 2515ecd543be..6dc00b6e1632 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/grpc_asyncio.py @@ -61,11 +61,7 @@ class _LoggingClientAIOInterceptor(grpc.aio.UnaryUnaryClientInterceptor): # pragma: NO COVER async def intercept_unary_unary(self, continuation, client_call_details, request): - logging_enabled = ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(std_logging.DEBUG) - and _LOGGER.hasHandlers() - ) + logging_enabled = CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(std_logging.DEBUG) and _LOGGER.hasHandlers() if logging_enabled: # pragma: NO COVER request_metadata = client_call_details.metadata if isinstance(request, proto.Message): diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py index 054dc001d66d..1c65061b1d9d 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/google/cloud/storagebatchoperations_v1/services/storage_batch_operations/transports/rest.py @@ -728,11 +728,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -781,11 +777,7 @@ def __call__(self, resp = self._interceptor.post_cancel_job(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_cancel_job_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = storage_batch_operations.CancelJobResponse.to_json(response) except: @@ -888,11 +880,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -939,11 +927,7 @@ def __call__(self, resp = self._interceptor.post_create_job(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_create_job_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -1038,11 +1022,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1163,11 +1143,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1215,11 +1191,7 @@ def __call__(self, resp = self._interceptor.post_get_bucket_operation(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_bucket_operation_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = storage_batch_operations_types.BucketOperation.to_json(response) except: @@ -1320,11 +1292,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1372,11 +1340,7 @@ def __call__(self, resp = self._interceptor.post_get_job(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_get_job_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = storage_batch_operations_types.Job.to_json(response) except: @@ -1478,11 +1442,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1530,11 +1490,7 @@ def __call__(self, resp = self._interceptor.post_list_bucket_operations(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_bucket_operations_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = storage_batch_operations.ListBucketOperationsResponse.to_json(response) except: @@ -1633,11 +1589,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1685,11 +1637,7 @@ def __call__(self, resp = self._interceptor.post_list_jobs(resp) response_metadata = [(k, str(v)) for k, v in response.headers.items()] resp, _ = self._interceptor.post_list_jobs_with_metadata(resp, response_metadata) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = storage_batch_operations.ListJobsResponse.to_json(response) except: @@ -1848,11 +1796,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -1896,11 +1840,7 @@ def __call__(self, resp = locations_pb2.Location() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_location(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2003,11 +1943,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2051,11 +1987,7 @@ def __call__(self, resp = locations_pb2.ListLocationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_locations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2156,11 +2088,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2282,11 +2210,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2410,11 +2334,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2458,11 +2378,7 @@ def __call__(self, resp = operations_pb2.Operation() resp = json_format.Parse(content, resp) resp = self._interceptor.post_get_operation(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: @@ -2565,11 +2481,7 @@ def __call__(self, rest_numeric_enums=False, ) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER request_url = "{host}{uri}".format(host=self._host, uri=transcoded_request['uri']) method = transcoded_request['method'] try: @@ -2613,11 +2525,7 @@ def __call__(self, resp = operations_pb2.ListOperationsResponse() resp = json_format.Parse(content, resp) resp = self._interceptor.post_list_operations(resp) - if ( - CLIENT_LOGGING_SUPPORTED - and _LOGGER.isEnabledFor(logging.DEBUG) - and _LOGGER.hasHandlers() - ): # pragma: NO COVER + if CLIENT_LOGGING_SUPPORTED and _LOGGER.isEnabledFor(logging.DEBUG) and _LOGGER.hasHandlers(): # pragma: NO COVER try: response_payload = json_format.MessageToJson(resp) except: From e1e043d32a97013627f4068dd3d35805b39de4c3 Mon Sep 17 00:00:00 2001 From: Daniel Sanche Date: Thu, 12 Nov 2026 21:44:28 -0700 Subject: [PATCH 4/4] simplified tests --- .../%name_%version/%sub/test_%service.py.j2 | 98 +++---------------- .../unit/gapic/asset_v1/test_asset_service.py | 98 +++---------------- .../credentials_v1/test_iam_credentials.py | 98 +++---------------- .../unit/gapic/eventarc_v1/test_eventarc.py | 98 +++---------------- .../logging_v2/test_config_service_v2.py | 98 +++---------------- .../logging_v2/test_logging_service_v2.py | 98 +++---------------- .../logging_v2/test_metrics_service_v2.py | 98 +++---------------- .../logging_v2/test_config_service_v2.py | 98 +++---------------- .../logging_v2/test_logging_service_v2.py | 98 +++---------------- .../logging_v2/test_metrics_service_v2.py | 98 +++---------------- .../unit/gapic/redis_v1/test_cloud_redis.py | 98 +++---------------- .../unit/gapic/redis_v1/test_cloud_redis.py | 98 +++---------------- .../unit/gapic/showcase_v1beta1/test_echo.py | 98 +++---------------- .../gapic/showcase_v1beta1/test_identity.py | 98 +++---------------- .../gapic/showcase_v1beta1/test_messaging.py | 98 +++---------------- .../test_resumable_upload_service.py | 98 +++---------------- .../showcase_v1beta1/test_sequence_service.py | 98 +++---------------- .../gapic/showcase_v1beta1/test_testing.py | 98 +++---------------- .../test_storage_batch_operations.py | 98 +++---------------- 19 files changed, 266 insertions(+), 1596 deletions(-) diff --git a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 index 530d109d3f6a..e8ebf6f280ee 100644 --- a/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 +++ b/packages/gapic-generator/gapic/templates/tests/unit/gapic/%name_%version/%sub/test_%service.py.j2 @@ -2819,95 +2819,25 @@ def test_{{ service.name|snake_case }}_base_transport_wrap_async_method_older_ap assert "is_streaming" not in kwargs -def test_{{ service.name|snake_case }}_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_{{ service.name|snake_case }}_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_{{ service.name|snake_case }}_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_{{ service.name|snake_case }}_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_{{ service.name|snake_case }}_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers {% endif %} {% endblock %} diff --git a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py index 81469c36292d..ea45b7e1825a 100755 --- a/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py +++ b/packages/gapic-generator/tests/integration/goldens/asset/tests/unit/gapic/asset_v1/test_asset_service.py @@ -18753,92 +18753,22 @@ def test_asset_service_base_transport_wrap_async_method_older_api_core_fallbacks assert "is_streaming" not in kwargs -def test_asset_service_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_asset_service_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_asset_service_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_asset_service_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_asset_service_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py index ff223857df2f..f18777d9e46e 100755 --- a/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py +++ b/packages/gapic-generator/tests/integration/goldens/credentials/tests/unit/gapic/credentials_v1/test_iam_credentials.py @@ -4799,92 +4799,22 @@ def test_iam_credentials_base_transport_wrap_async_method_older_api_core_fallbac assert "is_streaming" not in kwargs -def test_iam_credentials_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_iam_credentials_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_iam_credentials_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_iam_credentials_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_iam_credentials_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py index a221aa8781b0..4f7df64c67fc 100755 --- a/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py +++ b/packages/gapic-generator/tests/integration/goldens/eventarc/tests/unit/gapic/eventarc_v1/test_eventarc.py @@ -33856,92 +33856,22 @@ def test_eventarc_base_transport_wrap_async_method_older_api_core_fallbacks(monk assert "is_streaming" not in kwargs -def test_eventarc_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_eventarc_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_eventarc_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_eventarc_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_eventarc_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py index 71d16fb7e96c..4279bedb87df 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_config_service_v2.py @@ -14350,92 +14350,22 @@ def test_config_service_v2_base_transport_wrap_async_method_older_api_core_fallb assert "is_streaming" not in kwargs -def test_config_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_config_service_v2_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_config_service_v2_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_config_service_v2_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_config_service_v2_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py index ba12df1d0894..5a035cae0322 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_logging_service_v2.py @@ -4790,92 +4790,22 @@ def test_logging_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "is_streaming" not in kwargs -def test_logging_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_logging_service_v2_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_logging_service_v2_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_logging_service_v2_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_logging_service_v2_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py index 510fefda55b9..003491c6869e 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging/tests/unit/gapic/logging_v2/test_metrics_service_v2.py @@ -4590,92 +4590,22 @@ def test_metrics_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "is_streaming" not in kwargs -def test_metrics_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_metrics_service_v2_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_metrics_service_v2_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py index 1696024e31f6..a1ce0784c0f8 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_config_service_v2.py @@ -14350,92 +14350,22 @@ def test_config_service_v2_base_transport_wrap_async_method_older_api_core_fallb assert "is_streaming" not in kwargs -def test_config_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_config_service_v2_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_config_service_v2_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_config_service_v2_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_config_service_v2_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py index ba12df1d0894..5a035cae0322 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_logging_service_v2.py @@ -4790,92 +4790,22 @@ def test_logging_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "is_streaming" not in kwargs -def test_logging_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_logging_service_v2_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_logging_service_v2_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_logging_service_v2_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_logging_service_v2_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py index 2cba6c3932c0..e7ac3b0fc61e 100755 --- a/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py +++ b/packages/gapic-generator/tests/integration/goldens/logging_internal/tests/unit/gapic/logging_v2/test_metrics_service_v2.py @@ -4590,92 +4590,22 @@ def test_metrics_service_v2_base_transport_wrap_async_method_older_api_core_fall assert "is_streaming" not in kwargs -def test_metrics_service_v2_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_metrics_service_v2_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_metrics_service_v2_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_metrics_service_v2_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py index 2e133edb1b54..a45861f1285f 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py +++ b/packages/gapic-generator/tests/integration/goldens/redis/tests/unit/gapic/redis_v1/test_cloud_redis.py @@ -13644,92 +13644,22 @@ def test_cloud_redis_base_transport_wrap_async_method_older_api_core_fallbacks(m assert "is_streaming" not in kwargs -def test_cloud_redis_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_cloud_redis_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_cloud_redis_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_cloud_redis_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_cloud_redis_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py index 11d0f250ed28..bb33238f15d5 100755 --- a/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py +++ b/packages/gapic-generator/tests/integration/goldens/redis_selective/tests/unit/gapic/redis_v1/test_cloud_redis.py @@ -8864,92 +8864,22 @@ def test_cloud_redis_base_transport_wrap_async_method_older_api_core_fallbacks(m assert "is_streaming" not in kwargs -def test_cloud_redis_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_cloud_redis_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_cloud_redis_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_cloud_redis_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_cloud_redis_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py index 98e55de0c084..97ba5e222c4c 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_echo.py @@ -10123,92 +10123,22 @@ def test_echo_base_transport_wrap_async_method_older_api_core_fallbacks(monkeypa assert "is_streaming" not in kwargs -def test_echo_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_echo_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_echo_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_echo_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_echo_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py index 3e9037417aa3..29b9ae229f8e 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_identity.py @@ -7230,92 +7230,22 @@ def test_identity_base_transport_wrap_async_method_older_api_core_fallbacks(monk assert "is_streaming" not in kwargs -def test_identity_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_identity_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_identity_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_identity_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_identity_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py index a95accee268f..3deb15c4a03e 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_messaging.py @@ -12130,92 +12130,22 @@ def test_messaging_base_transport_wrap_async_method_older_api_core_fallbacks(mon assert "is_streaming" not in kwargs -def test_messaging_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_messaging_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_messaging_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_messaging_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_messaging_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py index 1ca0c22282cb..b950ccd63d6a 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_resumable_upload_service.py @@ -4823,92 +4823,22 @@ def test_resumable_upload_service_base_transport_wrap_async_method_older_api_cor assert "is_streaming" not in kwargs -def test_resumable_upload_service_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_resumable_upload_service_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_resumable_upload_service_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_resumable_upload_service_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_resumable_upload_service_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py index b9462975377a..996a03c264fc 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_sequence_service.py @@ -7912,92 +7912,22 @@ def test_sequence_service_base_transport_wrap_async_method_older_api_core_fallba assert "is_streaming" not in kwargs -def test_sequence_service_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_sequence_service_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_sequence_service_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_sequence_service_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_sequence_service_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py index 7cb09435855b..a692bb1acd82 100755 --- a/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py +++ b/packages/gapic-generator/tests/integration/goldens/showcase/tests/unit/gapic/showcase_v1beta1/test_testing.py @@ -8101,92 +8101,22 @@ def test_testing_base_transport_wrap_async_method_older_api_core_fallbacks(monke assert "is_streaming" not in kwargs -def test_testing_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_testing_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_testing_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_testing_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_testing_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers diff --git a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py index 3aa585a949c9..287a3f631326 100755 --- a/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py +++ b/packages/gapic-generator/tests/integration/goldens/storagebatchoperations/tests/unit/gapic/storagebatchoperations_v1/test_storage_batch_operations.py @@ -8800,92 +8800,22 @@ def test_storage_batch_operations_base_transport_wrap_async_method_older_api_cor assert "is_streaming" not in kwargs -def test_storage_batch_operations_grpc_logging_interceptor_requires_handlers(monkeypatch): - std_logging = transports.grpc.std_logging - logger = std_logging.getLogger("test_no_handlers_storage_batch_operations_sync") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - +@pytest.mark.parametrize("has_handlers", [True, False]) +def test_storage_batch_operations_grpc_logging_interceptor_has_handlers( + monkeypatch, has_handlers +): + logger = mock.MagicMock() + logger.isEnabledFor.return_value = True + logger.hasHandlers.return_value = has_handlers monkeypatch.setattr(transports.grpc, "CLIENT_LOGGING_SUPPORTED", True) monkeypatch.setattr(transports.grpc, "_LOGGER", logger) - interceptor = transports.grpc._LoggingClientInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) response = mock.MagicMock() - response.result.side_effect = AssertionError("result() should not be called without handlers") - continuation = mock.MagicMock(return_value=response) - - out = interceptor.intercept_unary_unary(continuation, call_details, object()) + response.result.return_value = "ok" + response.trailing_metadata.return_value = () + out = transports.grpc._LoggingClientInterceptor().intercept_unary_unary( + lambda *_: response, mock.MagicMock(metadata=()), "req" + ) assert out is response - response.result.assert_not_called() - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - logger.addHandler(_ListHandler()) - try: - response.result.side_effect = None - response.result.return_value = "ok" - response.trailing_metadata.return_value = () - out = interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is response - assert len(records) == 2 - finally: - logger.handlers = [] - - -@pytest.mark.asyncio -async def test_storage_batch_operations_grpc_aio_logging_interceptor_requires_handlers( - monkeypatch, -): - std_logging = transports.grpc_asyncio.std_logging - logger = std_logging.getLogger("test_no_handlers_storage_batch_operations_async") - logger.handlers = [] - logger.setLevel(std_logging.DEBUG) - logger.propagate = False - - monkeypatch.setattr(transports.grpc_asyncio, "CLIENT_LOGGING_SUPPORTED", True) - monkeypatch.setattr(transports.grpc_asyncio, "_LOGGER", logger) - - interceptor = transports.grpc_asyncio._LoggingClientAIOInterceptor() - call_details = mock.MagicMock(method="/test.Service/Method", metadata=()) - - class _NoAwaitResponse: - def __await__(self): - raise AssertionError("response should not be awaited without handlers") - - sentinel = _NoAwaitResponse() - continuation = AsyncMock(return_value=sentinel) - - out = await interceptor.intercept_unary_unary(continuation, call_details, object()) - assert out is sentinel - - records = [] - - class _ListHandler(std_logging.Handler): - def emit(self, record): - records.append(record) - - class _AwaitableResponse: - async def trailing_metadata(self): - return () - - def __await__(self): - async def _coro(): - return "ok" - - return _coro().__await__() - - logger.addHandler(_ListHandler()) - try: - aio_response = _AwaitableResponse() - continuation = AsyncMock(return_value=aio_response) - out = await interceptor.intercept_unary_unary(continuation, call_details, "req") - assert out is aio_response - assert len(records) == 2 - finally: - logger.handlers = [] + assert response.result.called is has_handlers + assert logger.debug.called is has_handlers