brass-runtime 1.18.1 → 1.19.0

package/dist/{chunk-7GBJYOX7.mjs → chunk-OX6MF7SZ.mjs}

@@ -1,6 +1,6 @@
 import {
   RuntimeService
-} from "./chunk-YWLLH27R.mjs";
+} from "./chunk-3NKXUX4T.mjs";
 import {
   exemplarFromTraceContext,
   injectTraceContext,
@@ -13,33 +13,29 @@ import {
   spanEvent,
   validateHttpObservabilityOptions,
   withSpan
-} from "./chunk-COOW7BJX.mjs";
+} from "./chunk-URVS2OE2.mjs";
 import {
   HttpClientService,
   getHttpRequestPolicy,
   httpErrorStatus,
   isRetryableHttpError,
   makeDefaultHttpClient
-} from "./chunk-Z3ZZMQUZ.mjs";
+} from "./chunk-5RVHSBJ6.mjs";
 import {
   registerHttpEffect
 } from "./chunk-MOO4L7F4.mjs";
 import {
   layerEffect,
   makeServiceTag
-} from "./chunk-EEN5OTCR.mjs";
+} from "./chunk-KDXNWGPB.mjs";
 import {
   Runtime,
   fromPromiseAbortable,
   getCurrentFiber
-} from "./chunk-H626ZTDZ.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;