@@ -19,7 +19,7 @@
 import * as serializer from 'proto3-json-serializer';
 import {defaultToObjectOptions} from './fallback';
 import {FetchParameters, FetchParametersMethod} from './fallbackServiceStub';
-import {GoogleError} from './googleError';
+import {GoogleError, setRawHttpResponsePayload} from './googleError';
 import {rpcCodeFromHttpStatusCode} from './status';
 import {getMatchedUrlTemplate, transcode} from './transcoding';
 
@@ -160,7 +160,7 @@ export function decodeResponse(
     if (ok) {
       throw err;
     }
-    throw _undecodableErrorResponse(
+    const undecodableError = _undecodableErrorResponse(
       rpc,
       httpStatusCode,
       `the response body is not JSON: ${
@@ -170,6 +170,8 @@ export function decodeResponse(
       }`,
       err,
     );
+    setRawHttpResponsePayload(undecodableError, decodedString);
+    throw undecodableError;
   }
   if (!ok) {
     let error: GoogleError;
@@ -179,12 +181,14 @@ export function decodeResponse(
       // `parseHttpError` indexes into the body, so JSON that parses but is not
       // an object — `null`, a string, a number — fails there for the same
       // reason an HTML body fails above, and must not lose the status either.
-      throw _undecodableErrorResponse(
+      const undecodableError = _undecodableErrorResponse(
         rpc,
         httpStatusCode,
         'the response body is not a JSON error object',
         err,
       );
+      setRawHttpResponsePayload(undecodableError, decodedString);
+      throw undecodableError;
     }
     // `parseHttpError` reads the status out of the response body and maps it
     // onto the gRPC `code`, keeping no record of the status the transport
@@ -197,6 +201,7 @@ export function decodeResponse(
     if (httpStatusCode !== undefined) {
       error.httpStatusCode = httpStatusCode;
     }
+    setRawHttpResponsePayload(error, decodedString);
     throw error;
   }
   const message = serializer.fromProto3JSON(rpc.resolvedResponseType!, json);
 
@@ -24,7 +24,7 @@ import * as serializer from 'proto3-json-serializer';
 import {isNodeJS} from './featureDetection';
 import {StreamArrayParser} from './streamArrayParser';
 import {defaultToObjectOptions} from './fallback';
-import {GoogleError} from './googleError';
+import {GoogleError, setRawHttpResponsePayload} from './googleError';
 import {setAttemptHttpMethod} from './observability/TracerHelper';
 import {rpcCodeFromHttpStatusCode, Status} from './status';
 import {pipeline, PipelineSource} from 'stream';
@@ -234,6 +234,43 @@ function _parseHttpErrorFromRejection(
   return undefined;
 }
 
+const GAXIOS_REDACTED_BODY =
+  '<<REDACTED> - See `errorRedactor` option in `gaxios` for configuration>.';
+
+function _isStreamLike(value: unknown): boolean {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const stream = value as {pipe?: unknown; getReader?: unknown};
+  return (
+    typeof stream.pipe === 'function' || typeof stream.getReader === 'function'
+  );
+}
+
+function _extractRawPayloadFromRejection(
+  err: Error,
+  responseData: unknown,
+  httpStatus: number,
+): unknown {
+  if (
+    responseData !== undefined &&
+    responseData !== null &&
+    responseData !== '' &&
+    responseData !== GAXIOS_REDACTED_BODY &&
+    !_isStreamLike(responseData)
+  ) {
+    return responseData;
+  }
+  if (
+    err.message.length > 0 &&
+    err.message !== GAXIOS_REDACTED_BODY &&
+    err.message !== `Request failed with status code ${httpStatus}`
+  ) {
+    return err.message;
+  }
+  return undefined;
+}
+
 function _toGoogleError(err: unknown, outcome: CallOutcome): unknown {
   if (err instanceof GoogleError) {
     return err;
@@ -264,13 +301,22 @@ function _toGoogleError(err: unknown, outcome: CallOutcome): unknown {
       ? fetchError.status
       : fetchError.response?.status;
   if (typeof httpStatus === 'number') {
+    const responseData = fetchError.response?.data;
     const parsedError =
-      _parseHttpErrorFromRejection(err, fetchError.response?.data) ?? error;
+      _parseHttpErrorFromRejection(err, responseData) ?? error;
     parsedError.cause = err;
     if (typeof parsedError.code !== 'number') {
       parsedError.code = rpcCodeFromHttpStatusCode(httpStatus);
     }
     parsedError.httpStatusCode = httpStatus;
+    const rawPayload = _extractRawPayloadFromRejection(
+      err,
+      responseData,
+      httpStatus,
+    );
+    if (rawPayload !== undefined) {
+      setRawHttpResponsePayload(parsedError, rawPayload);
+    }
     return parsedError;
   }
 
 
@@ -29,6 +29,34 @@ const UNKNOWN_TYPE_ENCONDED_ERROR_PREFIX = 'Unknown type encoded in';
 const UNKNOWN_TYPE_NO_SUCH_TYPE = 'no such type';
 
 const NUM_OF_PARTS_IN_PROTO_TYPE_NAME = 2;
+const RAW_HTTP_RESPONSE_PAYLOAD = Symbol.for(
+  'google-gax.rawHttpResponsePayload',
+);
+
+/**
+ * Attaches the full raw HTTP response body non-enumerably to a GoogleError so
+ * telemetry debug logging can report `response.payload` without altering
+ * standard error formatting or serialization.
+ */
+export function setRawHttpResponsePayload(
+  err: GoogleError,
+  payload: unknown,
+): void {
+  Object.defineProperty(err, RAW_HTTP_RESPONSE_PAYLOAD, {
+    value: payload,
+    configurable: true,
+    enumerable: false,
+    writable: true,
+  });
+}
+
+/**
+ * Reads the raw HTTP response body previously attached by
+ * {@link setRawHttpResponsePayload}, if any.
+ */
+export function getRawHttpResponsePayload(err: object): unknown {
+  return (err as Record<symbol, unknown>)[RAW_HTTP_RESPONSE_PAYLOAD];
+}
 
 export class GoogleError extends Error {
   code?: Status;
 
@@ -30,11 +30,11 @@ import {
 import {
   resolveErrorInfoDomain,
   resolveErrorInfoMetadataAttributes,
+  resolveErrorResponsePayload,
   resolveErrorType,
   resolveExceptionMessage,
   resolveExceptionStacktrace,
   resolveExceptionType,
-  resolveResponsePayload,
   resolveResponseStatusCode,
   resolveRpcStatusName,
 } from './errorUtil';
@@ -61,19 +61,15 @@ export interface LogPayload {
 }
 
 /**
- * Resolves a `LogSeverity` value across `google-logging-utils` versions where
- * `LogSeverity` may be exported as a type only.
+ * Resolves a `LogSeverity` enum value. Until a `google-logging-utils` release
+ * containing #9718 is published to npm (this repo uses `link-workspace-packages=false`),
+ * the published package exports `LogSeverity` as a type only while each enum member's
+ * runtime value equals its uppercase level string.
  */
 function resolveLogSeverity(
   level: 'DEBUG' | 'INFO' | 'WARNING' | 'ERROR',
 ): loggingUtils.LogSeverity {
-  return (
-    (
-      loggingUtils as {
-        LogSeverity?: Record<string, loggingUtils.LogSeverity>;
-      }
-    ).LogSeverity?.[level] ?? (level as loggingUtils.LogSeverity)
-  );
+  return level as loggingUtils.LogSeverity;
 }
 
 /**
@@ -153,22 +149,32 @@ export function buildLogAttributes(
 
 /**
  * Executes `fn` and attaches stream, promise, callback, or synchronous error
- * handlers to invoke `onError` when the operation fails.
+ * handlers to invoke `onError` at most once when the operation fails.
  */
 function executeLoggedOperation<T>(
   fn: (loggedCallback?: APICallback) => T,
   onError: (err: unknown) => void,
   isStreamCall: boolean,
   userCallback?: APICallback,
 ): T {
+  // Latch to emit at most one log per invocation across execution boundaries.
+  let hasLogged = false;
+  const logOnce = (err: unknown) => {
+    if (hasLogged) {
+      return;
+    }
+    hasLogged = true;
+    onError(err);
+  };
+
   // Wrap user callback to log RPC errors before forwarding.
   let callbackInvoked = false;
   const loggedCallback: APICallback | undefined = userCallback
     ? function (this: unknown, ...args: Parameters<APICallback>) {
         callbackInvoked = true;
         const err = args[0];
         if (err) {
-          onError(err);
+          logOnce(err);
         }
         userCallback.apply(this, args);
       }
@@ -179,15 +185,15 @@ function executeLoggedOperation<T>(
     const result = fn(loggedCallback);
     const promiseTarget = !isStreamCall ? getPromiseTarget(result) : null;
     if (isStreamCall && result instanceof EventEmitter) {
-      handleStream(result, onError, () => {}, Boolean(loggedCallback));
+      handleStream(result, logOnce, () => {}, Boolean(loggedCallback));
     } else if (promiseTarget) {
-      handlePromise(promiseTarget, onError, () => {});
+      handlePromise(promiseTarget, logOnce, () => {});
     }
     return result;
   } catch (syncErr) {
     // Avoid logging errors thrown inside userCallback after RPC completion.
     if (!callbackInvoked) {
-      onError(syncErr);
+      logOnce(syncErr);
     }
     throw syncErr;
   }
@@ -213,18 +219,10 @@ export function logCall<T = GaxCallResult>(
   isStreamCall = false,
   userCallback?: APICallback,
 ): T {
-  // Latch to emit at most one warning log per logical request.
-  let hasLoggedL3 = false;
   // Snapshot initial context in case async rejection loses active context.
   const initialContext = context.active();
 
   const emitL3WarnLog = (err: unknown) => {
-    // Suppress duplicate emissions for the same call.
-    if (hasLoggedL3) {
-      return;
-    }
-    hasLoggedL3 = true;
-
     // Resolve logger and active T3 client request span (or outer OpenTelemetry span when GAX tracing is disabled).
     const logger = getGaxLogger(staticArgs?.gcpClientService);
     const activeTrace = getActiveTraceContext();
@@ -288,20 +286,22 @@ export function logNetworkAttempt<T = GaxCallResult>(
   const initialContext = context.active();
 
   const emitL4DebugLog = (err: unknown) => {
-    // Resolve logger and active T4 attempt span context for this attempt.
+    // Resolve logger and active T4 attempt span (or outer OpenTelemetry span when GAX tracing is disabled).
     const logger = getGaxLogger(staticArgs?.gcpClientService);
+    const activeTrace = getActiveTraceContext();
+    const initialTrace = getActiveTraceContext(initialContext);
     const attemptSpan =
-      getActiveTraceContext()?.attemptSpan ??
-      getActiveTraceContext(initialContext)?.attemptSpan;
+      activeTrace?.attemptSpan ??
+      initialTrace?.attemptSpan ??
+      activeTrace?.span ??
+      initialTrace?.span;
     const spanContext = attemptSpan?.spanContext();
     const traceId = spanContext?.traceId;
     const spanId = spanContext?.spanId;
 
-    // Build structured log attributes and attach attempt metadata payload.
+    // Build structured log attributes and attach raw attempt response payload when present.
     const attributes = buildLogAttributes(err, attemptDynamicArgs, staticArgs);
-    const responsePayload = resolveResponsePayload(
-      (err as {metadata?: unknown} | null | undefined)?.metadata,
-    );
+    const responsePayload = resolveErrorResponsePayload(err);
     if (responsePayload !== undefined) {
       attributes['response.payload'] = responsePayload;
     }