brass-runtime 1.17.0 → 1.18.1

package/dist/{chunk-VWIPB6I5.js → chunk-YGR2IN4R.js}

@@ -1,3 +1,6 @@
+import {
+  RuntimeService
+} from "./chunk-LSYQ3C2M.js";
 import {
   exemplarFromTraceContext,
   injectTraceContext,
@@ -6,19 +9,33 @@ import {
   makeRequestObservabilityContext,
   normalizeHttpRoute,
   sanitizeHttpTarget,
+  shouldSampleWith,
   spanEvent,
   validateHttpObservabilityOptions,
   withSpan
-} from "./chunk-BKK77SBA.js";
+} from "./chunk-YZ5LQ32F.js";
 import {
+  HttpClientService,
   getHttpRequestPolicy,
   httpErrorStatus,
-  isRetryableHttpError
-} from "./chunk-3Y2RIUMM.js";
+  isRetryableHttpError,
+  makeDefaultHttpClient
+} from "./chunk-WUDHOZIH.js";
+import {
+  registerHttpEffect
+} from "./chunk-TRM4JUZQ.js";
 import {
+  layerEffect,
+  makeServiceTag
+} from "./chunk-S4HXADU4.js";
+import {
+  Runtime,
+  fromPromiseAbortable,
   getCurrentFiber
-} from "./chunk-FH2X7BVP.js";
+} from "./chunk-TTSPIU3U.js";
 import {
+  Cause,
+  asyncEffect,
   asyncFail,
   asyncFlatMap,
   asyncFold,
@@ -28,6 +45,9 @@ import {
 
 // src/observability/http.ts
 var DEFAULT_DURATION_BUCKETS = [1, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4];
+var MAX_HTTP_METRIC_CACHE_ENTRIES = 4096;
+var EMPTY_SPAN_ATTRIBUTES = Object.freeze({});
+var TRACE_SAMPLER_RATIO = /* @__PURE__ */ Symbol.for("brass-runtime.traceSampler.ratio");
 var POLICY_LABEL_NAMES = {
   preset: "policy",
   lane: "lane",
@@ -103,10 +123,19 @@ function withHttpObservability(options) {
     validateHttpObservabilityOptions(options ?? {});
   }
   const resolved = resolveHttpObservabilityOptions(options);
+  const metricCache = makeHttpMetricCache();
+  attachMetricCache(resolved.metrics, metricCache);
   return (next) => {
+    const adaptiveLimiter = adaptiveLimiterOf(next);
+    if (canUseLeanHttpMetricsPath(resolved, adaptiveLimiter)) {
+      return withLeanHttpMetricsObservability(next, resolved, metricCache);
+    }
+    if (canUseLeanHttpSampledSpanPath(resolved, adaptiveLimiter)) {
+      return withLeanHttpSampledSpanObservability(next, resolved, metricCache);
+    }
     return (req) => {
       const run = asyncFlatMap(
-        beginHttpObservation(req, resolved),
+        beginHttpObservation(req, resolved, metricCache),
         (state) => asyncFlatMap(
           logHttpRequest(req, resolved),
           () => asyncFlatMap(
@@ -116,23 +145,25 @@ function withHttpObservability(options) {
               (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(
-                  spanEvent("http.client.error", {
-                    ...finish.spanAttributes,
-                    ...adaptiveLimiterAttrs,
-                    "error.type": error._tag
-                  }),
+                  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(
-                  spanEvent("http.client.response", {
-                    ...finish.spanAttributes,
-                    ...adaptiveLimiterAttrs
-                  }),
+                  traceEvent,
                   () => asyncFlatMap(logHttpResponse(req, res, finish, resolved), () => asyncSucceed(res))
                 );
               }
@@ -146,26 +177,410 @@ function withHttpObservability(options) {
   };
 }
 var makeHttpObservabilityMiddleware = withHttpObservability;
-function beginHttpObservation(req, options) {
+var metricResetRegistry = /* @__PURE__ */ new WeakMap();
+function canUseLeanHttpMetricsPath(options, adaptiveLimiter) {
+  return Boolean(
+    options.metrics && options.logs === false && options.spans === false && !options.injectTraceHeaders && (!options.adaptiveLimiter.enabled || !adaptiveLimiter)
+  );
+}
+function canUseLeanHttpSampledSpanPath(options, adaptiveLimiter) {
+  return Boolean(
+    options.spans !== false && options.spans.events === false && options.logs === false && !options.injectTraceHeaders && (!options.adaptiveLimiter.enabled || !adaptiveLimiter)
+  );
+}
+function withLeanHttpSampledSpanObservability(next, options, metricCache) {
+  return (req) => asyncEffect((env, cb) => {
+    const startedAt = options.clock();
+    const baseLabels = requestBaseLabels(req, options);
+    const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
+    const span = startLeanHttpSpan(req, options);
+    let finished = false;
+    let cancelInner;
+    const finish = (exit) => {
+      if (finished) return;
+      finished = true;
+      cancelInner = void 0;
+      if (exit._tag === "Success") {
+        recordHttpMetricsFinish(
+          handles,
+          httpStatusOutcome(exit.value.status),
+          String(exit.value.status),
+          startedAt,
+          options,
+          metricCache
+        );
+        finishLeanHttpSpan(span, "success");
+      } else {
+        const error = httpErrorFromCause(exit.cause);
+        const status = httpErrorStatus(error);
+        recordHttpMetricsFinish(
+          handles,
+          httpErrorOutcome(error),
+          status !== void 0 ? String(status) : void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+        finishLeanHttpSpan(span, Cause.containsInterrupt(exit.cause) ? "interrupted" : "failure", error);
+      }
+      cb(exit);
+    };
+    try {
+      cancelInner = registerHttpEffect(next(req), env, finish);
+    } catch (error) {
+      const defectExit = {
+        _tag: "Failure",
+        cause: Cause.die(error)
+      };
+      finish(defectExit);
+    }
+    return () => {
+      if (!finished) {
+        finished = true;
+        recordHttpMetricsFinish(
+          handles,
+          "abort",
+          void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+        finishLeanHttpSpan(span, "interrupted");
+      }
+      const cancel = cancelInner;
+      cancelInner = void 0;
+      cancel?.();
+    };
+  });
+}
+function withLeanHttpMetricsObservability(next, options, metricCache) {
+  return (req) => asyncEffect((env, cb) => {
+    const startedAt = options.clock();
+    const baseLabels = requestBaseLabels(req, options);
+    const handles = beginLeanHttpMetricsObservation(baseLabels, options, metricCache);
+    let finished = false;
+    let cancelInner;
+    const finish = (exit) => {
+      if (finished) return;
+      finished = true;
+      cancelInner = void 0;
+      if (exit._tag === "Success") {
+        recordHttpMetricsFinish(
+          handles,
+          httpStatusOutcome(exit.value.status),
+          String(exit.value.status),
+          startedAt,
+          options,
+          metricCache
+        );
+      } else {
+        const error = httpErrorFromCause(exit.cause);
+        const status = httpErrorStatus(error);
+        recordHttpMetricsFinish(
+          handles,
+          httpErrorOutcome(error),
+          status !== void 0 ? String(status) : void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+      }
+      cb(exit);
+    };
+    try {
+      cancelInner = registerHttpEffect(next(req), env, finish);
+    } catch (error) {
+      const defectExit = {
+        _tag: "Failure",
+        cause: Cause.die(error)
+      };
+      finish(defectExit);
+    }
+    return () => {
+      if (!finished) {
+        finished = true;
+        recordHttpMetricsFinish(
+          handles,
+          "abort",
+          void 0,
+          startedAt,
+          options,
+          metricCache
+        );
+      }
+      const cancel = cancelInner;
+      cancelInner = void 0;
+      cancel?.();
+    };
+  });
+}
+function beginLeanHttpMetricsObservation(baseLabels, options, metricCache) {
+  const cacheKey = metricCacheKey("brass_http_client", baseLabels);
+  const existing = metricCache.disabled ? void 0 : metricCache.leanEntries.get(cacheKey);
+  if (existing) {
+    existing.inFlight?.increment();
+    return existing;
+  }
+  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 created = {
+    baseLabels,
+    inFlight,
+    finishMetrics: /* @__PURE__ */ new Map()
+  };
+  if (!metricCache.disabled && metricCache.leanEntries.size < MAX_HTTP_METRIC_CACHE_ENTRIES) {
+    metricCache.leanEntries.set(cacheKey, created);
+  }
+  return created;
+}
+function recordHttpMetricsFinish(handles, outcome, status, startedAt, options, metricCache) {
+  const durationMs = Math.max(0, options.clock() - startedAt);
+  handles.inFlight?.decrement();
+  if (!options.metrics) return;
+  const finishKey = `${outcome}|${status ?? "none"}`;
+  let finishMetrics = metricCache.disabled ? void 0 : handles.finishMetrics.get(finishKey);
+  if (!finishMetrics) {
+    const labels = requestFinishLabelsFromBase(handles.baseLabels, outcome, status);
+    finishMetrics = {
+      counter: options.metrics.counter("brass_http_client_requests_total", labels),
+      histogram: options.metrics.histogram(
+        "brass_http_client_duration_ms",
+        [...options.durationBuckets ?? DEFAULT_DURATION_BUCKETS],
+        labels
+      )
+    };
+    if (!metricCache.disabled) handles.finishMetrics.set(finishKey, finishMetrics);
+  }
+  finishMetrics.counter.increment();
+  finishMetrics.histogram.observe(durationMs);
+}
+function startLeanHttpSpan(req, options) {
+  const configuredSampleRate = options.spans === false ? void 0 : options.spans.sampleRate;
+  if (configuredSampleRate !== void 0) {
+    if (configuredSampleRate <= 0) return void 0;
+    if (configuredSampleRate < 1 && Math.random() >= configuredSampleRate) return void 0;
+  }
+  const fiber = getCurrentFiber();
+  const runtime = fiber?.runtime;
+  const sink = options.spanSink ?? runtime?.hooks;
+  if (!fiber?.fiberContext || !runtime || !sink) return void 0;
+  const previousTrace = fiber.fiberContext.trace ?? null;
+  const brass = runtime.env?.brass;
+  if (previousTrace?.sampled === false && brass?.respectRemoteSampled !== false) return void 0;
+  const name = spanName(req, options.spans);
+  const tracer = resolveRuntimeTracer(runtime);
+  let traceId = previousTrace?.traceId;
+  let sampled = previousTrace?.sampled;
+  let attributes;
+  if (!previousTrace && configuredSampleRate === void 0) {
+    const ratio = traceSamplerRatio(brass?.sampler);
+    if (ratio !== void 0) {
+      if (ratio <= 0) return void 0;
+      if (ratio < 1 && Math.random() >= ratio) return void 0;
+      sampled = true;
+    }
+    traceId = tracer.newTraceId();
+  } else if (!previousTrace) {
+    sampled = true;
+    traceId = tracer.newTraceId();
+  }
+  attributes = spanStartAttributes(req, options);
+  if (sampled === void 0) {
+    traceId = traceId ?? tracer.newTraceId();
+    sampled = shouldSampleWith(brass?.sampler, {
+      traceId,
+      spanName: name,
+      parentSampled: previousTrace?.sampled,
+      attributes
+    });
+  }
+  if (sampled === false) return void 0;
+  const trace = {
+    traceId: traceId ?? tracer.newTraceId(),
+    spanId: tracer.newSpanId(),
+    parentSpanId: previousTrace?.spanId,
+    sampled: true,
+    traceState: previousTrace?.traceState,
+    ...previousTrace?.baggage ? { baggage: previousTrace.baggage } : {}
+  };
+  const state = {
+    fiber,
+    sink,
+    previousTrace,
+    trace,
+    name,
+    ended: false
+  };
+  fiber.fiberContext = { ...fiber.fiberContext, trace };
+  fiber.addFinalizer?.((exit) => {
+    const status = exit?._tag === "Success" ? "success" : exit?.cause && Cause.containsInterrupt(exit.cause) ? "interrupted" : "failure";
+    finishLeanHttpSpan(state, status, exit?._tag === "Failure" ? exit.cause : void 0);
+  });
+  sink.emit(
+    { type: "span.start", name, attributes, links: [] },
+    leanSpanContext(fiber, trace)
+  );
+  return state;
+}
+function finishLeanHttpSpan(state, status, error) {
+  if (!state || state.ended) return;
+  state.ended = true;
+  state.sink.emit(
+    { type: "span.end", name: state.name, status, error },
+    leanSpanContext(state.fiber, state.trace)
+  );
+  if (state.fiber?.fiberContext) {
+    state.fiber.fiberContext = { ...state.fiber.fiberContext, trace: state.previousTrace };
+  }
+}
+function leanSpanContext(fiber, trace) {
+  return {
+    fiberId: fiber?.id,
+    scopeId: fiber?.scopeId,
+    traceId: trace.traceId,
+    spanId: trace.spanId,
+    parentSpanId: trace.parentSpanId,
+    traceState: trace.traceState,
+    baggage: trace.baggage,
+    sampled: trace.sampled
+  };
+}
+function resolveRuntimeTracer(runtime) {
+  const tracer = runtime?.env?.brass?.tracer;
+  if (tracer?.newTraceId && tracer?.newSpanId) return tracer;
+  return {
+    newTraceId: () => randomRuntimeId("trace"),
+    newSpanId: () => randomRuntimeId("span")
+  };
+}
+function traceSamplerRatio(sampler) {
+  if (!sampler || typeof sampler === "function") return void 0;
+  const ratio = sampler[TRACE_SAMPLER_RATIO];
+  return typeof ratio === "number" && Number.isFinite(ratio) ? ratio : void 0;
+}
+function randomRuntimeId(prefix) {
+  const cryptoLike = globalThis.crypto;
+  if (typeof cryptoLike?.randomUUID === "function") return cryptoLike.randomUUID();
+  return `${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function httpErrorFromCause(cause) {
+  const failure = Cause.firstFailure(cause);
+  if (failure._tag === "Some") return failure.value;
+  if (Cause.containsInterrupt(cause)) return { _tag: "Abort" };
+  const defect = Cause.firstDefect(cause);
+  const value = defect._tag === "Some" ? defect.value : Cause.toError(cause);
+  return {
+    _tag: "FetchError",
+    message: value instanceof Error ? value.message : String(value),
+    cause: value
+  };
+}
+function makeHttpMetricCache() {
+  return {
+    disabled: false,
+    leanEntries: /* @__PURE__ */ new Map(),
+    inFlightGauges: /* @__PURE__ */ new Map(),
+    requestCounters: /* @__PURE__ */ new Map(),
+    durationHistograms: /* @__PURE__ */ new Map()
+  };
+}
+function attachMetricCache(metrics, cache) {
+  if (!metrics) return;
+  const existing = metricResetRegistry.get(metrics);
+  if (existing) {
+    existing.caches.add(cache);
+    return;
+  }
+  const entry = {
+    caches: /* @__PURE__ */ new Set([cache]),
+    reset: metrics.reset.bind(metrics)
+  };
+  try {
+    Object.defineProperty(metrics, "reset", {
+      configurable: true,
+      value: () => {
+        for (const cached of entry.caches) clearHttpMetricCache(cached);
+        entry.reset();
+      }
+    });
+    metricResetRegistry.set(metrics, entry);
+  } catch {
+    cache.disabled = true;
+  }
+}
+function clearHttpMetricCache(cache) {
+  cache.leanEntries.clear();
+  cache.inFlightGauges.clear();
+  cache.requestCounters.clear();
+  cache.durationHistograms.clear();
+}
+function getCachedMetric(owner, cache, key, create) {
+  if (owner.disabled) return create();
+  const existing = cache.get(key);
+  if (existing) return existing;
+  const created = create();
+  if (cache.size < MAX_HTTP_METRIC_CACHE_ENTRIES) {
+    cache.set(key, created);
+  }
+  return created;
+}
+function metricCacheKey(name, labels) {
+  let key = name;
+  for (const [label, value] of Object.entries(labels)) {
+    key += `|${label.length}:${label}=${value.length}:${value}`;
+  }
+  return key;
+}
+function beginHttpObservation(req, options, metricCache) {
   return asyncSync(() => {
     const startedAt = options.clock();
     let finished = false;
-    const inFlight = options.metrics?.gauge("brass_http_client_in_flight", requestBaseLabels(req, options));
+    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 = requestFinishLabels(req, outcome, status, options);
+      const labels = requestFinishLabelsFromBase(baseLabels, outcome, status);
       if (!finished) {
         finished = true;
         if (inFlight && inFlight.value() > 0) inFlight.decrement();
-        options.metrics?.counter("brass_http_client_requests_total", labels).increment();
-        options.metrics?.histogram("brass_http_client_duration_ms", [...options.durationBuckets ?? DEFAULT_DURATION_BUCKETS], labels).observe(durationMs, currentTraceExemplar(durationMs, startedAt + durationMs));
+        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: {
+        spanAttributes: options.spans === false ? EMPTY_SPAN_ATTRIBUTES : {
           "http.duration_ms": durationMs,
           "http.outcome": outcome,
           ...status ? { "http.status_code": Number(status) } : {},
@@ -234,6 +649,7 @@ function resolveHttpObservabilityOptions(options) {
     metrics: raw?.metrics === false ? void 0 : raw?.metrics,
     logs: raw?.logs ?? {},
     spans: raw?.spans ?? {},
+    spanSink: raw?.spanSink === false ? void 0 : raw?.spanSink,
     adaptiveLimiter: resolveAdaptiveLimiterObservabilityOptions(raw?.adaptiveLimiter),
     policy: resolveHttpPolicyObservabilityOptions(raw?.policy),
     injectTraceHeaders: raw?.injectTraceHeaders ?? true,
@@ -330,6 +746,9 @@ function spanName(req, options) {
   }
   return `HTTP ${req.method}`;
 }
+function shouldEmitHttpSpanEvents(options) {
+  return options.spans !== false && options.spans.events !== false;
+}
 function spanStartAttributes(req, options) {
   const spanOptions = options.spans === false ? {} : options.spans.attributes;
   const custom = typeof spanOptions === "function" ? spanOptions(req) : spanOptions ?? {};
@@ -361,9 +780,9 @@ function requestBaseLabels(req, options) {
     ...requestPolicyMetricLabels(req, options)
   });
 }
-function requestFinishLabels(req, outcome, status, options) {
+function requestFinishLabelsFromBase(baseLabels, outcome, status) {
   return {
-    ...requestBaseLabels(req, options),
+    ...baseLabels,
     outcome,
     status: status ?? "none"
   };
@@ -759,6 +1178,88 @@ function readProcessEnv() {
   return typeof process !== "undefined" ? process.env : {};
 }
 
+// src/observability/layer.ts
+var ObservabilityService = makeServiceTag("Observability");
+function makeObservabilityLayer(config = {}, options = {}) {
+  const tag = options.tag ?? ObservabilityService;
+  return layerEffect(
+    tag,
+    (context) => asyncSync(() => makeObservability(resolveObservabilityLayerConfig(config, context))),
+    shutdownObservability
+  );
+}
+function makeObservedRuntimeLayer(options = {}) {
+  const {
+    observabilityTag = ObservabilityService,
+    runtimeTag = RuntimeService,
+    env = {},
+    ...runtimeOptions
+  } = options;
+  return layerEffect(
+    runtimeTag,
+    (context) => asyncSync(() => {
+      const observability = context.unsafeGet(observabilityTag);
+      return new Runtime({
+        ...runtimeOptions,
+        env: mergeRuntimeEnv(resolveObservedRuntimeLayerEnv(env, context, observability), observability.env),
+        hooks: observability.hooks
+      });
+    })
+  );
+}
+function makeObservedHttpClientLayer(config = {}, options = {}) {
+  const observabilityTag = options.observabilityTag ?? ObservabilityService;
+  const httpTag = options.httpTag ?? HttpClientService;
+  return layerEffect(
+    httpTag,
+    (context) => asyncSync(() => {
+      const observability = context.unsafeGet(observabilityTag);
+      const httpConfig = resolveObservedHttpClientLayerConfig(config, context, observability);
+      const httpObservability = resolveObservedHttpObservabilityOptions(
+        options.httpObservability,
+        context,
+        observability
+      );
+      return makeDefaultHttpClient({
+        ...httpConfig,
+        middleware: [
+          ...httpConfig.middleware ?? [],
+          withHttpObservability({
+            metrics: observability.metrics,
+            ...httpObservability
+          })
+        ]
+      });
+    }),
+    shutdownDefaultHttpClient
+  );
+}
+function resolveObservabilityLayerConfig(config, context) {
+  return typeof config === "function" ? config(context) : config;
+}
+function resolveObservedHttpClientLayerConfig(config, context, observability) {
+  return typeof config === "function" ? config(context, observability) : config;
+}
+function resolveObservedHttpObservabilityOptions(options, context, observability) {
+  return typeof options === "function" ? options(context, observability) : options ?? {};
+}
+function resolveObservedRuntimeLayerEnv(env, context, observability) {
+  return typeof env === "function" ? env(context, observability) : env;
+}
+function mergeRuntimeEnv(env, observabilityEnv) {
+  return Object.assign({}, env, observabilityEnv);
+}
+function shutdownObservability(observability) {
+  return fromPromiseAbortable(
+    () => observability.shutdown().then(() => void 0),
+    () => void 0,
+    { label: "observability.shutdown" }
+  );
+}
+function shutdownDefaultHttpClient(client) {
+  return client.shutdown();
+}
+
 export {
   HTTP_OBSERVABILITY_CONTRACT,
   withHttpObservability,
@@ -773,5 +1274,9 @@ export {
   makeObservabilityPreset,
   makeObservabilityFromEnv,
   observabilityOptionsForPreset,
-  observabilityOptionsFromEnv
+  observabilityOptionsFromEnv,
+  ObservabilityService,
+  makeObservabilityLayer,
+  makeObservedRuntimeLayer,
+  makeObservedHttpClientLayer
 };