GeezerVison

If client_logging.is_error_logging_enabled or _observability.build_telemetry_error_attributes raises an exception, it will propagate out of _report_method_error and disrupt the caller's RPC flow. Wrapping the entire body of _report_method_error in a try...except Exception block ensures that telemetry and logging errors always fail open. To avoid silently masking underlying issues, log the exception as a warning instead of silently passing.

        try:
            error_logging_enabled = client_logging.is_error_logging_enabled(
                self._client_options
            )
            if span is None and not error_logging_enabled:
                return

            error_attrs = _observability.build_telemetry_error_attributes(
                exc, include_exception=error_logging_enabled
            )
            status_code = error_attrs.get("rpc.response.status_code", "")
            is_cancelled = status_code in ("CANCELLED", "CancelledError") or isinstance(
                exc, asyncio.CancelledError
            )
            if is_cancelled:
                error_attrs["rpc.response.status_code"] = "CANCELLED"

            # Enrich active Tier 3 method span
            if span is not None:
                for k, v in error_attrs.items():
                    if not k.startswith("exception."):
                        span.set_attribute(k, v)

            # Emit L2/L3 Terminal Method Error Log
            if error_logging_enabled:
                self._emit_method_error_log(
                    exc, span, error_attrs, is_cancelled, logger=logger
                )
        except Exception as e:
            logger.warning("Failed to report method error: %s", e)

Thanks for the review!

1. Isolating span.set_attribute in its own try...except Exception: pass block (separate from _emit_method_error_log's try...except Exception: pass block) is intentional so that a failing custom Span implementation cannot skip terminal error log emission (added a clarifying comment in ca5d711).
2. Keeping is_error_logging_enabled outside the try...except block preserves the fail-loud FeatureGatingError contract if an unsupported logger_provider option is passed.
3. Using except Exception: pass rather than logger.warning matches the fail-open observability contract across _observability.py so internal telemetry errors never emit unexpected warnings into user logs.

Mutating the error_attrs dictionary passed as an argument can lead to unexpected side-effects if the caller or other methods reuse it. It is safer to construct extra_payload first and then pop "exception.stacktrace" from extra_payload directly.

Fixed in ca5d711 — updated _emit_method_error_log to pop "exception.stacktrace" from extra_payload rather than mutating error_attrs in-place.