brass-runtime 1.18.0 → 1.18.2

package/dist/{chunk-3PFZGP23.cjs → chunk-OO7BGCC3.cjs}

@@ -6,7 +6,7 @@ var _chunkSA6HUJVIcjs = require('./chunk-SA6HUJVI.cjs');
 
 
 
-var _chunkSSQJKDN3cjs = require('./chunk-SSQJKDN3.cjs');
+var _chunkZDZNV6NAcjs = require('./chunk-ZDZNV6NA.cjs');
 
 
 
@@ -99,8 +99,8 @@ function makeMergePull(onLeft, onRight, flip, mergePullId) {
   const onLeftHandler = streamToRaceWithHandler("L", onLeft, onRight, flip, id);
   const onRightHandler = streamToRaceWithHandler("R", onLeft, onRight, flip, id);
   return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_env, cb) => {
-    const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
-    const scope = new (0, _chunkSSQJKDN3cjs.Scope)(runtime);
+    const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
+    const scope = new (0, _chunkZDZNV6NAcjs.Scope)(runtime);
     const handler = _chunkSA6HUJVIcjs.raceWith.call(void 0, 
       uncons(onLeft),
       uncons(onRight),
@@ -160,9 +160,9 @@ function uncons(self) {
       return makeMergePull(self.left, self.right, self.flip, 0);
     case "Scoped":
       return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-        const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
-        const scope = new (0, _chunkSSQJKDN3cjs.Scope)(runtime);
-        const fiber = _chunkSSQJKDN3cjs.getCurrentFiber.call(void 0, );
+        const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
+        const scope = new (0, _chunkZDZNV6NAcjs.Scope)(runtime);
+        const fiber = _chunkZDZNV6NAcjs.getCurrentFiber.call(void 0, );
         _optionalChain([fiber, 'optionalAccess', _2 => _2.addFinalizer, 'call', _3 => _3((exit) => {
           try {
             scope.close(exit);
@@ -183,7 +183,7 @@ function uncons(self) {
         const wrap = (s) => fromPull(
           _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env2, cb2) => {
             const pull = uncons(s);
-            _chunkSSQJKDN3cjs.unsafeRunFoldWithEnv.call(void 0, 
+            _chunkZDZNV6NAcjs.unsafeRunFoldWithEnv.call(void 0, 
               pull,
               env2,
               (cause) => {
@@ -206,14 +206,14 @@ function uncons(self) {
           }
           scope.addFinalizer((exit) => self.release(exit));
           const inner = ex.value;
-          _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
+          _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
         });
       });
     case "Managed":
       return _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env, cb) => {
-        const runtime = _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, );
-        const scope = new (0, _chunkSSQJKDN3cjs.Scope)(runtime);
-        _optionalChain([_chunkSSQJKDN3cjs.getCurrentFiber.call(void 0, ), 'optionalAccess', _4 => _4.addFinalizer, 'call', _5 => _5((exit) => {
+        const runtime = _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, );
+        const scope = new (0, _chunkZDZNV6NAcjs.Scope)(runtime);
+        _optionalChain([_chunkZDZNV6NAcjs.getCurrentFiber.call(void 0, ), 'optionalAccess', _4 => _4.addFinalizer, 'call', _5 => _5((exit) => {
           try {
             scope.close(exit);
           } catch (e4) {
@@ -241,7 +241,7 @@ function uncons(self) {
           scope.addFinalizer((exit) => release(exit));
           const wrap = (s) => fromPull(
             _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (env2, cb2) => {
-              _chunkSSQJKDN3cjs.unsafeRunFoldWithEnv.call(void 0, 
+              _chunkZDZNV6NAcjs.unsafeRunFoldWithEnv.call(void 0, 
                 uncons(s),
                 env2,
                 (cause) => {
@@ -255,7 +255,7 @@ function uncons(self) {
               );
             })
           );
-          _chunkSSQJKDN3cjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
+          _chunkZDZNV6NAcjs.unsafeGetCurrentRuntime.call(void 0, ).fork(uncons(wrap(inner))).join(cb);
         });
       });
   }
@@ -412,31 +412,49 @@ function drainStreamSyncFull(stream) {
     }
   }
 }
+var ABORTED_ERROR = (() => {
+  if (typeof DOMException === "function") {
+    try {
+      return new DOMException("aborted", "AbortError");
+    } catch (e5) {
+    }
+  }
+  const e = new Error("aborted");
+  e.name = "AbortError";
+  return e;
+})();
 function readerStream(reader, normalizeError, signal) {
+  const noopSignal = globalThis.__brassNoopSignal;
+  const needsSignalListener = signal !== void 0 && signal !== noopSignal;
   const pull = _chunkMVGUEJ5Zcjs.asyncEffect.call(void 0, (_, cb) => {
     let done = false;
-    const cleanup = () => _optionalChain([signal, 'optionalAccess', _6 => _6.removeEventListener, 'call', _7 => _7("abort", abort)]);
+    let abortFn;
     const finish = (exit) => {
       if (done) return;
       done = true;
-      cleanup();
+      if (needsSignalListener && abortFn) signal.removeEventListener("abort", abortFn);
       cb(exit);
     };
-    const abort = () => {
-      try {
-        reader.cancel();
-      } catch (e5) {
+    if (needsSignalListener) {
+      if (signal.aborted) {
+        try {
+          reader.cancel();
+        } catch (e6) {
+        }
+        finish({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkMVGUEJ5Zcjs.some.call(void 0, normalizeError(ABORTED_ERROR)) } });
+        return;
       }
-      const error = typeof DOMException === "function" ? new DOMException("aborted", "AbortError") : new Error("aborted");
-      finish({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkMVGUEJ5Zcjs.some.call(void 0, normalizeError(error)) } });
-    };
-    if (_optionalChain([signal, 'optionalAccess', _8 => _8.aborted])) {
-      abort();
-      return;
+      abortFn = () => {
+        try {
+          reader.cancel();
+        } catch (e7) {
+        }
+        finish({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkMVGUEJ5Zcjs.some.call(void 0, normalizeError(ABORTED_ERROR)) } });
+      };
+      signal.addEventListener("abort", abortFn, { once: true });
     }
-    _optionalChain([signal, 'optionalAccess', _9 => _9.addEventListener, 'call', _10 => _10("abort", abort, { once: true })]);
-    reader.read().then(({ done: done2, value }) => {
-      if (done2) {
+    reader.read().then(({ done: readDone, value }) => {
+      if (readDone) {
         finish({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkMVGUEJ5Zcjs.none } });
         return;
       }
@@ -444,14 +462,16 @@ function readerStream(reader, normalizeError, signal) {
         _tag: "Success",
         value: [value, fromPull(pull)]
       });
-    }).catch((e) => {
+    }, (e) => {
       finish({ _tag: "Failure", cause: { _tag: "Fail", error: _chunkMVGUEJ5Zcjs.some.call(void 0, normalizeError(e)) } });
     });
     return () => {
-      cleanup();
+      if (done) return;
+      done = true;
+      if (needsSignalListener && abortFn) signal.removeEventListener("abort", abortFn);
       try {
         reader.cancel();
-      } catch (e6) {
+      } catch (e8) {
       }
     };
   });
@@ -469,10 +489,10 @@ function streamFromReadableStream(body, normalizeError, options = {}) {
     // release: se corre en fin / error / interrupción
     () => _chunkMVGUEJ5Zcjs.asyncSync.call(void 0, () => {
       try {
-        _optionalChain([reader, 'optionalAccess', _11 => _11.cancel, 'call', _12 => _12()]);
-      } catch (e7) {
+        _optionalChain([reader, 'optionalAccess', _6 => _6.cancel, 'call', _7 => _7()]);
+      } catch (e9) {
       } finally {
-        _optionalChain([options, 'access', _13 => _13.onRelease, 'optionalCall', _14 => _14()]);
+        _optionalChain([options, 'access', _8 => _8.onRelease, 'optionalCall', _9 => _9()]);
       }
     })
   );

package/dist/{chunk-QCOLAHU3.mjs → chunk-OX6MF7SZ.mjs}

@@ -1,6 +1,6 @@
 import {
   RuntimeService
-} from "./chunk-ITZQ526U.mjs";
+} from "./chunk-3NKXUX4T.mjs";
 import {
   exemplarFromTraceContext,
   injectTraceContext,
@@ -13,33 +13,29 @@ import {
   spanEvent,
   validateHttpObservabilityOptions,
   withSpan
-} from "./chunk-KRYP6CAE.mjs";
+} from "./chunk-URVS2OE2.mjs";
 import {
   HttpClientService,
   getHttpRequestPolicy,
   httpErrorStatus,
   isRetryableHttpError,
   makeDefaultHttpClient
-} from "./chunk-Z3PSSXP3.mjs";
+} from "./chunk-5RVHSBJ6.mjs";
 import {
   registerHttpEffect
 } from "./chunk-MOO4L7F4.mjs";
 import {
   layerEffect,
   makeServiceTag
-} from "./chunk-ELLF55ER.mjs";
+} from "./chunk-KDXNWGPB.mjs";
 import {
   Runtime,
   fromPromiseAbortable,
   getCurrentFiber
-} from "./chunk-2QNREG6K.mjs";
+} from "./chunk-MUMBUXU6.mjs";
 import {
   Cause,
   asyncEffect,
-  asyncFail,
-  asyncFlatMap,
-  asyncFold,
-  asyncSucceed,
   asyncSync
 } from "./chunk-36I3M4UC.mjs";
 
@@ -134,43 +130,147 @@ function withHttpObservability(options) {
       return withLeanHttpSampledSpanObservability(next, resolved, metricCache);
     }
     return (req) => {
-      const run = asyncFlatMap(
-        beginHttpObservation(req, resolved, metricCache),
-        (state) => asyncFlatMap(
-          logHttpRequest(req, resolved),
-          () => asyncFlatMap(
-            prepareHttpRequest(req, resolved),
-            (wireReq) => asyncFold(
-              next(wireReq),
-              (error) => {
-                const finish = state.finishWithError(error);
-                const adaptiveLimiterAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
-                const traceEvent = !shouldEmitHttpSpanEvents(resolved) ? asyncSucceed(void 0) : spanEvent("http.client.error", {
-                  ...finish.spanAttributes,
-                  ...adaptiveLimiterAttrs,
-                  "error.type": error._tag
-                });
-                return asyncFlatMap(
-                  traceEvent,
-                  () => asyncFlatMap(logHttpError(req, error, finish, resolved), () => asyncFail(error))
-                );
-              },
-              (res) => {
-                const finish = state.finishWithResponse(res);
-                const adaptiveLimiterAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
-                const traceEvent = !shouldEmitHttpSpanEvents(resolved) ? asyncSucceed(void 0) : spanEvent("http.client.response", {
-                  ...finish.spanAttributes,
-                  ...adaptiveLimiterAttrs
-                });
-                return asyncFlatMap(
-                  traceEvent,
-                  () => asyncFlatMap(logHttpResponse(req, res, finish, resolved), () => asyncSucceed(res))
-                );
-              }
-            )
-          )
-        )
-      );
+      const run = asyncEffect((env, cb) => {
+        const startedAt = resolved.clock();
+        const baseLabels = getCachedBaseLabels(req, resolved, metricCache);
+        const inFlight = resolved.metrics ? getCachedMetric(
+          metricCache,
+          metricCache.inFlightGauges,
+          metricCacheKey("brass_http_client_in_flight", baseLabels),
+          () => resolved.metrics.gauge("brass_http_client_in_flight", baseLabels)
+        ) : void 0;
+        inFlight?.increment();
+        let finished = false;
+        let cancelInner;
+        const completeFinish = (outcome, status, extra) => {
+          const durationMs = Math.max(0, resolved.clock() - startedAt);
+          const labels = requestFinishLabelsFromBase(baseLabels, outcome, status);
+          if (!finished) {
+            finished = true;
+            if (inFlight && inFlight.value() > 0) inFlight.decrement();
+            if (resolved.metrics) {
+              getCachedMetric(
+                metricCache,
+                metricCache.requestCounters,
+                metricCacheKey("brass_http_client_requests_total", labels),
+                () => resolved.metrics.counter("brass_http_client_requests_total", labels)
+              ).increment();
+              getCachedMetric(
+                metricCache,
+                metricCache.durationHistograms,
+                metricCacheKey("brass_http_client_duration_ms", labels),
+                () => resolved.metrics.histogram(
+                  "brass_http_client_duration_ms",
+                  [...resolved.durationBuckets ?? DEFAULT_DURATION_BUCKETS],
+                  labels
+                )
+              ).observe(
+                durationMs,
+                resolved.spans === false ? void 0 : currentTraceExemplar(durationMs, startedAt + durationMs)
+              );
+            }
+          }
+          return {
+            durationMs,
+            outcome,
+            labels,
+            spanAttributes: resolved.spans === false ? EMPTY_SPAN_ATTRIBUTES : {
+              "http.duration_ms": durationMs,
+              "http.outcome": outcome,
+              ...status ? { "http.status_code": Number(status) } : {},
+              ...status ? { "http.response.status_code": Number(status) } : {},
+              ...extra
+            }
+          };
+        };
+        const fiber = getCurrentFiber();
+        fiber?.addFinalizer?.(() => {
+          completeFinish("abort", void 0, { "http.cancelled": true });
+        });
+        const reqLogLevel = resolved.logs === false ? false : resolved.logs.requestLevel ?? false;
+        if (reqLogLevel) {
+          const logEff = logEffect(reqLogLevel, "http.client.request", requestLogFields(req, resolved));
+          registerHttpEffect(logEff, env, () => void 0);
+        }
+        const wireReq = resolved.injectTraceHeaders ? injectCurrentTraceContext(req) : req;
+        const onSuccess = (res) => {
+          const finish = completeFinish(httpStatusOutcome(res.status), String(res.status), {});
+          const adaptiveAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
+          if (shouldEmitHttpSpanEvents(resolved)) {
+            const ev = spanEvent("http.client.response", {
+              ...finish.spanAttributes,
+              ...adaptiveAttrs
+            });
+            registerHttpEffect(ev, env, () => void 0);
+          }
+          const respLevel = resolved.logs === false ? false : (resolved.logs.responseLevel ?? false) || (finish.outcome === "error" ? resolved.logs.errorLevel ?? "warn" : false);
+          if (respLevel) {
+            const logEff = logEffect(respLevel, "http.client.response", {
+              ...requestLogFields(req, resolved),
+              status: res.status,
+              statusText: res.statusText,
+              outcome: finish.outcome,
+              durationMs: finish.durationMs
+            });
+            registerHttpEffect(logEff, env, () => void 0);
+          }
+          cb({ _tag: "Success", value: res });
+        };
+        const onError = (error) => {
+          const status = httpErrorStatus(error);
+          const finish = completeFinish(
+            httpErrorOutcome(error),
+            status !== void 0 ? String(status) : void 0,
+            {
+              "error.type": error._tag,
+              "http.retryable": isRetryableHttpError(error)
+            }
+          );
+          const adaptiveAttrs = observeAdaptiveLimiter(wireReq, next, resolved);
+          if (shouldEmitHttpSpanEvents(resolved)) {
+            const ev = spanEvent("http.client.error", {
+              ...finish.spanAttributes,
+              ...adaptiveAttrs,
+              "error.type": error._tag
+            });
+            registerHttpEffect(ev, env, () => void 0);
+          }
+          const errLevel = resolved.logs === false ? false : resolved.logs.errorLevel ?? "error";
+          if (errLevel) {
+            const statusText = httpErrorStatusText(error);
+            const logEff = logEffect(errLevel, "http.client.error", {
+              ...requestLogFields(req, resolved),
+              outcome: finish.outcome,
+              durationMs: finish.durationMs,
+              ...status !== void 0 ? { status } : {},
+              ...statusText ? { statusText } : {},
+              retryable: isRetryableHttpError(error),
+              errorTag: error._tag,
+              message: httpErrorMessage(error)
+            });
+            registerHttpEffect(logEff, env, () => void 0);
+          }
+          cb({ _tag: "Failure", cause: Cause.fail(error) });
+        };
+        try {
+          cancelInner = registerHttpEffect(next(wireReq), env, (exit) => {
+            cancelInner = void 0;
+            if (exit._tag === "Success") onSuccess(exit.value);
+            else {
+              const failure = Cause.firstFailure(exit.cause);
+              if (failure._tag === "Some") onError(failure.value);
+              else cb(exit);
+            }
+          });
+        } catch (error) {
+          cb({ _tag: "Failure", cause: Cause.die(error) });
+        }
+        return () => {
+          const cancel = cancelInner;
+          cancelInner = void 0;
+          cancel?.();
+        };
+      });
       if (resolved.spans === false) return run;
       return withSpan(spanName(req, resolved.spans), run, spanStartAttributes(req, resolved));
     };
@@ -191,7 +291,7 @@ function canUseLeanHttpSampledSpanPath(options, adaptiveLimiter) {
 function withLeanHttpSampledSpanObservability(next, options, metricCache) {
   return (req) => asyncEffect((env, cb) => {
     const startedAt = options.clock();
-    const baseLabels = requestBaseLabels(req, options);
+    const baseLabels = getCachedBaseLabels(req, options, metricCache);
     const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
     const span = startLeanHttpSpan(req, options);
     let finished = false;
@@ -256,7 +356,7 @@ function withLeanHttpSampledSpanObservability(next, options, metricCache) {
 function withLeanHttpMetricsObservability(next, options, metricCache) {
   return (req) => asyncEffect((env, cb) => {
     const startedAt = options.clock();
-    const baseLabels = requestBaseLabels(req, options);
+    const baseLabels = getCachedBaseLabels(req, options, metricCache);
     const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
     let finished = false;
     let cancelInner;
@@ -486,9 +586,23 @@ function makeHttpMetricCache() {
     leanEntries: /* @__PURE__ */ new Map(),
     inFlightGauges: /* @__PURE__ */ new Map(),
     requestCounters: /* @__PURE__ */ new Map(),
-    durationHistograms: /* @__PURE__ */ new Map()
+    durationHistograms: /* @__PURE__ */ new Map(),
+    baseLabelsCache: /* @__PURE__ */ new Map()
   };
 }
+function getCachedBaseLabels(req, options, cache) {
+  if (cache.disabled) return requestBaseLabels(req, options);
+  const route = requestRoute(req, options);
+  const host = options.includeHostLabel ? requestHost(req) : void 0;
+  const policy = getHttpRequestPolicy(req);
+  const preset = typeof policy === "string" ? policy : policy?.preset;
+  const key = `${req.method}|${host ?? ""}|${route ?? ""}|${preset ?? ""}`;
+  const existing = cache.baseLabelsCache.get(key);
+  if (existing) return existing;
+  const fresh = requestBaseLabels(req, options);
+  cache.baseLabelsCache.set(key, fresh);
+  return fresh;
+}
 function attachMetricCache(metrics, cache) {
   if (!metrics) return;
   const existing = metricResetRegistry.get(metrics);
@@ -536,112 +650,6 @@ function metricCacheKey(name, labels) {
   }
   return key;
 }
-function beginHttpObservation(req, options, metricCache) {
-  return asyncSync(() => {
-    const startedAt = options.clock();
-    let finished = false;
-    const baseLabels = requestBaseLabels(req, options);
-    const inFlight = options.metrics ? getCachedMetric(
-      metricCache,
-      metricCache.inFlightGauges,
-      metricCacheKey("brass_http_client_in_flight", baseLabels),
-      () => options.metrics.gauge("brass_http_client_in_flight", baseLabels)
-    ) : void 0;
-    inFlight?.increment();
-    const finish = (outcome, status, extra = {}) => {
-      const durationMs = Math.max(0, options.clock() - startedAt);
-      const labels = requestFinishLabelsFromBase(baseLabels, outcome, status);
-      if (!finished) {
-        finished = true;
-        if (inFlight && inFlight.value() > 0) inFlight.decrement();
-        if (options.metrics) {
-          getCachedMetric(
-            metricCache,
-            metricCache.requestCounters,
-            metricCacheKey("brass_http_client_requests_total", labels),
-            () => options.metrics.counter("brass_http_client_requests_total", labels)
-          ).increment();
-          getCachedMetric(
-            metricCache,
-            metricCache.durationHistograms,
-            metricCacheKey("brass_http_client_duration_ms", labels),
-            () => options.metrics.histogram(
-              "brass_http_client_duration_ms",
-              [...options.durationBuckets ?? DEFAULT_DURATION_BUCKETS],
-              labels
-            )
-          ).observe(
-            durationMs,
-            options.spans === false ? void 0 : currentTraceExemplar(durationMs, startedAt + durationMs)
-          );
-        }
-      }
-      return {
-        durationMs,
-        outcome,
-        labels,
-        spanAttributes: options.spans === false ? EMPTY_SPAN_ATTRIBUTES : {
-          "http.duration_ms": durationMs,
-          "http.outcome": outcome,
-          ...status ? { "http.status_code": Number(status) } : {},
-          ...status ? { "http.response.status_code": Number(status) } : {},
-          ...extra
-        }
-      };
-    };
-    const fiber = getCurrentFiber();
-    fiber?.addFinalizer?.(() => {
-      finish("abort", void 0, { "http.cancelled": true });
-    });
-    return {
-      finishWithResponse: (res) => finish(httpStatusOutcome(res.status), String(res.status)),
-      finishWithError: (error) => {
-        const status = httpErrorStatus(error);
-        return finish(httpErrorOutcome(error), status !== void 0 ? String(status) : void 0, {
-          "error.type": error._tag,
-          "http.retryable": isRetryableHttpError(error)
-        });
-      }
-    };
-  });
-}
-function prepareHttpRequest(req, options) {
-  if (!options.injectTraceHeaders) return asyncSucceed(req);
-  return asyncSync(() => injectCurrentTraceContext(req));
-}
-function logHttpRequest(req, options) {
-  const level = options.logs === false ? false : options.logs.requestLevel ?? false;
-  if (!level) return asyncSucceed(void 0);
-  return logEffect(level, "http.client.request", requestLogFields(req, options));
-}
-function logHttpResponse(req, res, finish, options) {
-  const configured = options.logs === false ? false : options.logs.responseLevel ?? false;
-  const level = configured || (finish.outcome === "error" ? options.logs !== false ? options.logs.errorLevel ?? "warn" : false : false);
-  if (!level) return asyncSucceed(void 0);
-  return logEffect(level, "http.client.response", {
-    ...requestLogFields(req, options),
-    status: res.status,
-    statusText: res.statusText,
-    outcome: finish.outcome,
-    durationMs: finish.durationMs
-  });
-}
-function logHttpError(req, error, finish, options) {
-  const level = options.logs === false ? false : options.logs.errorLevel ?? "error";
-  if (!level) return asyncSucceed(void 0);
-  const status = httpErrorStatus(error);
-  const statusText = httpErrorStatusText(error);
-  return logEffect(level, "http.client.error", {
-    ...requestLogFields(req, options),
-    outcome: finish.outcome,
-    durationMs: finish.durationMs,
-    ...status !== void 0 ? { status } : {},
-    ...statusText ? { statusText } : {},
-    retryable: isRetryableHttpError(error),
-    errorTag: error._tag,
-    message: httpErrorMessage(error)
-  });
-}
 function resolveHttpObservabilityOptions(options) {
   const maybeObservability = isObservabilityInstance(options) ? options : void 0;
   const raw = maybeObservability ? { metrics: maybeObservability.metrics } : options;