effect 4.0.0-beta.99 → 4.0.0-rc.108

package/dist/Metric.js

@@ -16,6 +16,7 @@ import * as Duration from "./Duration.js";
 import { constUndefined, dual } from "./Function.js";
 import * as InternalEffect from "./internal/effect.js";
 import * as InternalMetric from "./internal/metric.js";
+import * as InternalRecord from "./internal/record.js";
 import * as Layer from "./Layer.js";
 import * as Order from "./Order.js";
 import { pipeArguments } from "./Pipeable.js";
@@ -26,12 +27,8 @@ import * as _String from "./String.js";
  *
  * **Example** (Accessing the current metric attributes key)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class AttributesKeyError extends Data.TaggedError("AttributesKeyError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // The key is used internally by the Effect runtime to manage metric attributes
@@ -65,9 +62,12 @@ import * as _String from "./String.js";
  *     isConstant: key === "effect/Metric/CurrentMetricAttributes" // true
  *   }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const key = result // => { keyValue: "effect/Metric/CurrentMetricAttributes", keyType: "string", isConstant: true }
  * ```
  *
- * @category references
+ * @category constants
  * @since 4.0.0
  */
 export const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes";
@@ -88,17 +88,12 @@ export const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes
  *
  * **Example** (Providing current metric attributes)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class AttributesError extends Data.TaggedError("AttributesError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Access current metric attributes
- *   const attributes = yield* Metric.CurrentMetricAttributes
- *   console.log("Current attributes:", attributes)
+ *   yield* Metric.CurrentMetricAttributes
  *
  *   // Set new attributes context
  *   const newAttributes = { service: "api", version: "1.0" }
@@ -113,9 +108,12 @@ export const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes
  *
  *   return result
  * })
+ *
+ * const attributes = await Effect.runPromise(program)
+ * const actual = attributes // => { service: "api", version: "1.0" }
  * ```
  *
- * @category references
+ * @category services
  * @since 4.0.0
  */
 export const CurrentMetricAttributes = /*#__PURE__*/Context.Reference(CurrentMetricAttributesKey, {
@@ -145,7 +143,7 @@ const MetricRegistryKey = "~effect/observability/Metric/MetricRegistryKey";
  * @see {@link snapshot} for reading all registered metrics from the current `Effect` context
  * @see {@link snapshotUnsafe} for reading all registered metrics from an explicit `Context`
  *
- * @category references
+ * @category services
  * @since 4.0.0
  */
 export const MetricRegistry = /*#__PURE__*/Context.Reference(MetricRegistryKey, {
@@ -294,7 +292,7 @@ class HistogramMetric extends Metric$ {
     let count = 0;
     let sum = 0;
     let min = Number.MAX_VALUE;
-    let max = Number.MIN_VALUE;
+    let max = -Number.MAX_VALUE;
     Arr.map(Arr.sort(bounds, Order.Number), (n, i) => {
       boundaries[i] = n;
     });
@@ -372,7 +370,7 @@ class SummaryMetric extends Metric$ {
     let count = 0;
     let sum = 0;
     let min = Number.MAX_VALUE;
-    let max = Number.MIN_VALUE;
+    let max = -Number.MAX_VALUE;
     const snapshot = now => {
       const builder = [];
       let i = 0;
@@ -393,8 +391,8 @@ class SummaryMetric extends Metric$ {
         return sortedQuantiles.map(q => [q, undefined]);
       }
       // Compute the value of the quantile in terms of rank:
-      // > For a given quantile `q`, return the maximum value `v` such that at
-      // > most `q * n` values are less than or equal to `v`.
+      // For a given quantile `q`, return the maximum value `v` such that at
+      // most `q * n` values are less than or equal to `v`.
       return sortedQuantiles.map(q => {
         if (q <= 0) return [q, samples[0]];
         if (q >= 1) return [q, samples[sampleSize - 1]];
@@ -460,23 +458,17 @@ class MetricTransform extends Metric$ {
  *
  * **Example** (Checking metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Metric } from "effect"
  *
- * const counter = Metric.counter("requests")
- * const gauge = Metric.gauge("temperature")
- * const notAMetric = { name: "fake-metric" }
- *
- * console.log(Metric.isMetric(counter)) // true
- * console.log(Metric.isMetric(gauge)) // true
- * console.log(Metric.isMetric(notAMetric)) // false
- * console.log(Metric.isMetric(null)) // false
+ * Metric.isMetric(Metric.counter("requests")) // => true
+ * Metric.isMetric({ name: "requests" }) // => false
  * ```
  *
  * @category guards
  * @since 4.0.0
  */
-export const isMetric = u => Predicate.hasProperty(u, "~effect/Metric") && u["~effect/Metric"] === "~effect/Metric";
+export const isMetric = u => Predicate.hasProperty(u, TypeId) && u[TypeId] === TypeId;
 /**
  * Represents a Counter metric that tracks cumulative numerical values over
  * time. Counters can be incremented and decremented and provide a running total
@@ -491,12 +483,8 @@ export const isMetric = u => Predicate.hasProperty(u, "~effect/Metric") && u["~e
  *
  * **Example** (Creating counter metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class CounterError extends Data.TaggedError("CounterError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a basic counter for tracking requests
@@ -530,6 +518,9 @@ export const isMetric = u => Predicate.hasProperty(u, "~effect/Metric") && u["~e
  *
  *   return { requestValue, eventValue, bytesValue }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const counts = [result.requestValue.count, result.eventValue.count, result.bytesValue.count] // => [6, 1, 1024n]
  * ```
  *
  * @category constructors
@@ -553,12 +544,8 @@ export const counter = (name, options) => new CounterMetric(name, options);
  *
  * **Example** (Creating gauge metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class GaugeError extends Data.TaggedError("GaugeError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a gauge for tracking memory usage
@@ -597,6 +584,9 @@ export const counter = (name, options) => new CounterMetric(name, options);
  *
  *   return { memoryValue, cpuValue, diskValue }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.memoryValue.value, result.cpuValue.value, result.diskValue.value] // => [800, 75, 1024000000n]
  * ```
  *
  * @category constructors
@@ -620,12 +610,8 @@ export const gauge = (name, options) => new GaugeMetric(name, options);
  *
  * **Example** (Creating frequency metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class FrequencyError extends Data.TaggedError("FrequencyError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a frequency metric for HTTP status codes
@@ -675,6 +661,14 @@ export const gauge = (name, options) => new GaugeMetric(name, options);
  *
  *   return { statusCounts, actionCounts, errorCounts }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const counts = [
+ *   result.statusCounts.occurrences.get("200"),
+ *   result.actionCounts.occurrences.get("login"),
+ *   result.errorCounts.occurrences.get("ValidationError")
+ * ]
+ * counts // => [3, 2, 2]
  * ```
  *
  * @category constructors
@@ -697,19 +691,15 @@ export const frequency = (name, options) => new FrequencyMetric(name, options);
  *
  * **Example** (Creating histogram metrics)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class HistogramError extends Data.TaggedError("HistogramError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a histogram for API response times
  *   const responseTimeHistogram = Metric.histogram("api_response_time", {
  *     description: "Distribution of API response times in milliseconds",
  *     boundaries: Metric.linearBoundaries({ start: 0, width: 50, count: 10 })
- *     // Creates buckets: 0-50ms, 50-100ms, 100-150ms, ..., 400-450ms, 450ms+
+ *     // Creates buckets: 0-50ms, 50-100ms, 100-150ms, ..., 350-400ms, 400ms+
  *   })
  *
  *   // Create a histogram for request payload sizes
@@ -749,6 +739,10 @@ export const frequency = (name, options) => new FrequencyMetric(name, options);
  *
  *   return { responseTimeState, payloadSizeState }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.responseTimeState.count, result.responseTimeState.sum, result.payloadSizeState.count]
+ * values // => [5, 500, 3]
  * ```
  *
  * @category constructors
@@ -773,12 +767,8 @@ export const histogram = (name, options) => new HistogramMetric(name, options);
  *
  * **Example** (Creating summary metrics)
  *
- * ```ts
- * import { Data, Duration, Effect, Metric } from "effect"
- *
- * class SummaryError extends Data.TaggedError("SummaryError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Duration, Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create a summary for API response times
@@ -814,24 +804,16 @@ export const histogram = (name, options) => new HistogramMetric(name, options);
  *   const responseStats = yield* Metric.value(responseTimeSummary)
  *   const payloadStats = yield* Metric.value(payloadSizeSummary)
  *
- *   console.log({
- *     count: responseStats.count,
- *     min: responseStats.min,
- *     max: responseStats.max,
- *     sum: responseStats.sum
- *   }) // { count: 8, min: 82, max: 240, sum: 1155 }
- *
- *   console.log({
- *     count: payloadStats.count,
- *     min: payloadStats.min,
- *     max: payloadStats.max,
- *     sum: payloadStats.sum
- *   }) // { count: 4, min: 1.2, max: 15.6, sum: 26 }
- *
  *   // Both summaries include quantile information for their configured windows.
  *
  *   return { responseStats, payloadStats }
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const response = result.responseStats
+ * const payload = result.payloadStats
+ * const responseValues = [response.count, response.min, response.max, response.sum] // => [8, 82, 240, 1155]
+ * const payloadValues = [payload.count, payload.min, payload.max, payload.sum] // => [4, 1.2, 15.6, 26]
  * ```
  *
  * @category constructors
@@ -859,7 +841,7 @@ export const summary = (name, options) => mapInput(summaryWithTimestamp(name, op
  *
  * **Example** (Creating summaries with explicit timestamps)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Metric } from "effect"
  *
  * const responseTimesSummary = Metric.summaryWithTimestamp(
@@ -871,6 +853,7 @@ export const summary = (name, options) => mapInput(summaryWithTimestamp(name, op
  *     quantiles: [0.5, 0.9, 0.99] // Calculate 50th, 90th, and 99th quantiles.
  *   }
  * )
+ * const metadata = [responseTimesSummary.id, responseTimesSummary.type] // => ["response_times_summary", "Summary"]
  * ```
  *
  * @category constructors
@@ -891,12 +874,8 @@ export const summaryWithTimestamp = (name, options) => new SummaryMetric(name, o
  *
  * **Example** (Recording durations with a timer)
  *
- * ```ts
- * import { Data, Duration, Effect, Metric } from "effect"
- *
- * class TimerError extends Data.TaggedError("TimerError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Duration, Effect, Metric } from "effect"
  *
  * // Create a timer metric to track API request durations
  * const apiRequestTimer = Metric.timer("api_request_duration", {
@@ -910,13 +889,17 @@ export const summaryWithTimestamp = (name, options) => new SummaryMetric(name, o
  *   yield* Metric.update(apiRequestTimer, duration)
  *
  *   const state = yield* Metric.value(apiRequestTimer)
- *   console.log({
+ *   return {
  *     count: state.count,
  *     min: state.min,
  *     max: state.max,
  *     sum: state.sum
- *   }) // { count: 1, min: 120, max: 120, sum: 120 }
+ *   }
  * })
+ *
+ * await Effect.runPromise(
+ *   Effect.provideService(apiOperation, Metric.MetricRegistry, new Map())
+ * ) // => { count: 1, min: 120, max: 120, sum: 120 }
  * ```
  *
  * @category constructors
@@ -952,10 +935,10 @@ export const timer = (name, options) => {
  *
  * **Example** (Reading metric state)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
- * const requestCounter = Metric.counter("requests")
+ * const requestCounter = Metric.counter("modify_requests")
  * const responseTime = Metric.histogram("response_time", {
  *   boundaries: [100, 500, 1000, 2000]
  * })
@@ -967,16 +950,19 @@ export const timer = (name, options) => {
  *
  *   // Get current values
  *   const counterState = yield* Metric.value(requestCounter)
- *   console.log(`Request count: ${counterState.count}`)
- *
  *   const histogramState = yield* Metric.value(responseTime)
- *   console.log(`Response time stats:`, {
+ *   return {
+ *     requestCount: counterState.count,
  *     count: histogramState.count,
  *     min: histogramState.min,
  *     max: histogramState.max,
  *     average: histogramState.sum / histogramState.count
- *   })
+ *   }
  * })
+ *
+ * await Effect.runPromise(
+ *   Effect.provideService(program, Metric.MetricRegistry, new Map())
+ * ) // => { requestCount: 1, count: 1, min: 750, max: 750, average: 750 }
  * ```
  *
  * @category getters
@@ -996,7 +982,7 @@ export const value = self => InternalEffect.flatMap(InternalEffect.context(), co
  *
  * **Example** (Modifying metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const temperatureGauge = Metric.gauge("temperature")
@@ -1016,10 +1002,10 @@ export const value = self => InternalEffect.flatMap(InternalEffect.context(), co
  *
  *   const temp = yield* Metric.value(temperatureGauge)
  *   const requests = yield* Metric.value(requestCounter)
- *
- *   console.log(`Temperature: ${temp.value}°C`) // 22°C
- *   console.log(`Requests: ${requests.count}`) // 15
+ *   return [temp.value, requests.count] as const
  * })
+ *
+ * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [22, 15]
  * ```
  *
  * @category mutations
@@ -1039,7 +1025,7 @@ export const modify = /*#__PURE__*/dual(2, (self, input) => InternalEffect.flatM
  *
  * **Example** (Updating metric values)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const cpuUsage = Metric.gauge("cpu_usage_percent")
@@ -1067,11 +1053,10 @@ export const modify = /*#__PURE__*/dual(2, (self, input) => InternalEffect.flatM
  *   const cpu = yield* Metric.value(cpuUsage)
  *   const statuses = yield* Metric.value(httpStatus)
  *   const times = yield* Metric.value(responseTime)
- *
- *   console.log(`CPU Usage: ${cpu.value}%`)
- *   console.log(`Status 200 count: ${statuses.occurrences.get("200")}`) // 2
- *   console.log(`Response time samples: ${times.count}`) // 3
+ *   return [cpu.value, statuses.occurrences.get("200"), times.count] as const
  * })
+ *
+ * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => [67.8, 2, 3]
  * ```
  *
  * @category mutations
@@ -1085,36 +1070,30 @@ export const update = /*#__PURE__*/dual(2, (self, input) => InternalEffect.conte
  *
  * **Example** (Mapping metric inputs)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricError extends Data.TaggedError("MetricError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
- * // Create a histogram that expects Duration values
  * const durationHistogram = Metric.histogram("request_duration_ms", {
  *   description: "Request duration in milliseconds",
  *   boundaries: Metric.linearBoundaries({ start: 0, width: 100, count: 10 })
  * })
  *
- * // Transform to accept number values representing milliseconds
- * const numberHistogram = Metric.mapInput(
+ * // Accept duration strings while recording numeric milliseconds
+ * const durationStringHistogram = Metric.mapInput(
  *   durationHistogram,
- *   (ms: number) => ms // Direct mapping from number to expected input
+ *   (input: string) => Number(input)
  * )
  *
  * const program = Effect.gen(function*() {
- *   // Now we can update with a plain number
- *   yield* Metric.update(numberHistogram, 250)
- *
- *   // Get metric value to see the recorded state
- *   const value = yield* Metric.value(numberHistogram)
- *   return value
+ *   yield* Metric.update(durationStringHistogram, "250")
+ *   return yield* Metric.value(durationStringHistogram)
  * })
+ *
+ * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [value.count, value.sum] // => [1, 250]
  * ```
  *
- * @category mapping
+ * @category annotations
  * @since 2.0.0
  */
 export const mapInput = /*#__PURE__*/dual(2, (self, f) => new MetricTransform(self, context => self.valueUnsafe(context), (input, context) => self.updateUnsafe(f(input, context), context), (input, context) => self.modifyUnsafe(f(input, context), context)));
@@ -1125,12 +1104,8 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => new MetricTransform(se
  *
  * **Example** (Ignoring inputs with a constant value)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricError extends Data.TaggedError("MetricError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * // Create a counter that normally expects a number increment
  * const requestCounter = Metric.counter("total_requests", {
@@ -1149,9 +1124,12 @@ export const mapInput = /*#__PURE__*/dual(2, (self, f) => new MetricTransform(se
  *   const value = yield* Metric.value(simpleRequestCounter)
  *   return value // Counter state will show count: 3
  * })
+ *
+ * const value = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const count = value.count // => 3
  * ```
  *
- * @category Input
+ * @category mapping
  * @since 2.0.0
  */
 export const withConstantInput = /*#__PURE__*/dual(2, (self, input) => mapInput(self, () => input));
@@ -1166,7 +1144,7 @@ export const withConstantInput = /*#__PURE__*/dual(2, (self, input) => mapInput(
  *
  * **Example** (Applying metric attributes)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Effect, Metric } from "effect"
  *
  * const requestCounter = Metric.counter("http_requests_total", {
@@ -1199,18 +1177,17 @@ export const withConstantInput = /*#__PURE__*/dual(2, (self, input) => mapInput(
  *   yield* Metric.update(taggedMetric, 1) // http_requests_total{service="user-api", version="v1"}
  * })
  *
- * // When taking snapshots, each attribute combination appears as a separate metric
- * const viewMetrics = Effect.gen(function*() {
- *   const snapshots = yield* Metric.snapshot
- *   for (const metric of snapshots) {
- *     if (metric.id === "http_requests_total") {
- *       console.log(`${metric.id}`, metric.attributes, metric.state)
- *     }
- *   }
+ * const result = Effect.gen(function*() {
+ *   yield* program
+ *   const get = yield* Metric.value(getRequests)
+ *   const post = yield* Metric.value(postRequests)
+ *   return [get.count, post.count] as const
  * })
+ *
+ * await Effect.runPromise(Effect.provideService(result, Metric.MetricRegistry, new Map())) // => [2, 1]
  * ```
  *
- * @category Attributes
+ * @category mapping
  * @since 4.0.0
  */
 export const withAttributes = /*#__PURE__*/dual(2, (self, attributes) => new MetricTransform(self, context => self.valueUnsafe(addAttributesToContext(context, attributes)), (input, context) => self.updateUnsafe(input, addAttributesToContext(context, attributes)), (input, context) => self.modifyUnsafe(input, addAttributesToContext(context, attributes))));
@@ -1225,12 +1202,8 @@ export const withAttributes = /*#__PURE__*/dual(2, (self, attributes) => new Met
  *
  * **Example** (Capturing metric snapshots)
  *
- * ```ts
- * import { Console, Data, Effect, Metric } from "effect"
- *
- * class SnapshotError extends Data.TaggedError("SnapshotError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create and update some metrics
@@ -1251,19 +1224,16 @@ export const withAttributes = /*#__PURE__*/dual(2, (self, attributes) => new Met
  *   // Take a snapshot of all metrics
  *   const snapshots = yield* Metric.snapshot
  *
- *   // Examine the snapshots
- *   for (const snapshot of snapshots) {
- *     yield* Console.log(`Metric: ${snapshot.id}`)
- *     yield* Console.log(`Description: ${snapshot.description}`)
- *     yield* Console.log(`Type: ${snapshot.type}`)
- *     yield* Console.log(`State:`, snapshot.state)
- *   }
- *
  *   return snapshots
  * })
+ *
+ * const snapshots = await Effect.runPromise(
+ *   Effect.provideService(program, Metric.MetricRegistry, new Map())
+ * )
+ * const ids = snapshots.map((snapshot) => snapshot.id).sort() // => ["http_requests", "response_time_ms"]
  * ```
  *
- * @category Snapshotting
+ * @category snapshotting
  * @since 2.0.0
  */
 export const snapshot = /*#__PURE__*/InternalEffect.map(/*#__PURE__*/InternalEffect.context(), context => snapshotUnsafe(context));
@@ -1279,12 +1249,8 @@ export const snapshot = /*#__PURE__*/InternalEffect.map(/*#__PURE__*/InternalEff
  *
  * **Example** (Dumping metrics as text)
  *
- * ```ts
- * import { Console, Data, Effect, Metric } from "effect"
- *
- * class DumpError extends Data.TaggedError("DumpError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Create and update some metrics for demonstration
@@ -1308,20 +1274,21 @@ export const snapshot = /*#__PURE__*/InternalEffect.map(/*#__PURE__*/InternalEff
  *
  *   // Get formatted dump of all metrics
  *   const metricsReport = yield* Metric.dump
- *   yield* Console.log("Current Metrics:")
- *   yield* Console.log(metricsReport)
- *
- *   // Output will look like a formatted table:
- *   // Name                  Description                           Type       State
- *   // http_requests_total   Total HTTP requests                   Counter    [count: 2]
- *   // response_time_ms      Current response time in milliseconds Gauge      [value: 125]
- *   // http_status_codes     Frequency of HTTP status codes       Frequency  [occurrences: 200 -> 2, 404 -> 1]
- *
  *   return metricsReport
  * })
+ *
+ * const report = await Effect.runPromise(
+ *   Effect.provideService(program, Metric.MetricRegistry, new Map())
+ * )
+ * const included = [
+ *   report.includes("http_requests_total"),
+ *   report.includes("response_time_ms"),
+ *   report.includes("http_status_codes")
+ * ]
+ * included // => [true, true, true]
  * ```
  *
- * @category Debugging
+ * @category formatting
  * @since 4.0.0
  */
 export const dump = /*#__PURE__*/InternalEffect.flatMap(/*#__PURE__*/InternalEffect.context(), context => {
@@ -1367,56 +1334,20 @@ export const dump = /*#__PURE__*/InternalEffect.flatMap(/*#__PURE__*/InternalEff
  *
  * **Example** (Capturing snapshots from a context)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class UnsafeSnapshotError extends Data.TaggedError("UnsafeSnapshotError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Use unsafeSnapshot in performance-critical scenarios or internal implementations
- * const performanceMetricsExporter = Effect.gen(function*() {
- *   // Create some metrics first
- *   const requestCounter = Metric.counter("http_requests", {
- *     description: "Total HTTP requests"
- *   })
- *   const responseTime = Metric.gauge("response_time_ms", {
- *     description: "Current response time"
- *   })
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
- *   // Update metrics
+ * const requestCounter = Metric.counter("http_requests")
+ * const program = Effect.gen(function*() {
  *   yield* Metric.update(requestCounter, 1)
- *   yield* Metric.update(responseTime, 150)
- *
- *   // Get services context for unsafe operations
- *   const services = yield* Effect.context()
- *
- *   // Use snapshotUnsafe for direct, synchronous access
- *   const snapshots = Metric.snapshotUnsafe(services)
- *   const exportBatchCreatedAt = 1_700_000_000_000
- *
- *   // Process snapshots immediately (useful for exporters, debugging tools)
- *   const exportData = snapshots.map((snapshot) => ({
- *     name: snapshot.id,
- *     type: snapshot.type,
- *     value: snapshot.state,
- *     timestamp: exportBatchCreatedAt
- *   }))
- *
- *   // This is synchronous and doesn't involve Effect overhead
- *   // Useful for performance-critical metric export operations
- *   return exportData
+ *   const context = yield* Effect.context()
+ *   return Metric.snapshotUnsafe(context).map((snapshot) => snapshot.id)
  * })
  *
- * // For normal application use, prefer the safe snapshot function:
- * const safeSnapshotExample = Effect.gen(function*() {
- *   // This automatically handles the services context
- *   const snapshots = yield* Metric.snapshot
- *   return snapshots
- * })
+ * await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map())) // => ["http_requests"]
  * ```
  *
- * @category Snapshotting
+ * @category snapshotting
  * @since 4.0.0
  */
 export const snapshotUnsafe = context => {
@@ -1496,60 +1427,13 @@ const attributesToString = attributes => {
  *
  * **Example** (Creating boundaries from values)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class BoundaryError extends Data.TaggedError("BoundaryError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Create boundaries from an array of custom values
- * const customBoundaries = Metric.boundariesFromIterable([
- *   10,
- *   25,
- *   50,
- *   100,
- *   250,
- *   500,
- *   1000
- * ])
- * console.log(customBoundaries) // [10, 25, 50, 100, 250, 500, 1000, Infinity]
- *
- * // Automatically removes duplicates and negative values
- * const messyBoundaries = Metric.boundariesFromIterable([
- *   -5,
- *   0,
- *   10,
- *   10,
- *   25,
- *   25,
- *   50,
- *   -1
- * ])
- * console.log(messyBoundaries) // [10, 25, 50, Infinity]
- *
- * // Works with any iterable (Set, generator functions, etc.)
- * const setBoundaries = Metric.boundariesFromIterable(
- *   new Set([100, 200, 300, 200, 100])
- * )
- * console.log(setBoundaries) // [100, 200, 300, Infinity]
- *
- * // Use with histogram metric
- * const responseTimeHistogram = Metric.histogram("response_times", {
- *   description: "API response time distribution",
- *   boundaries: customBoundaries
- * })
- *
- * const program = Effect.gen(function*() {
- *   yield* Metric.update(responseTimeHistogram, 75) // Goes in 50-100ms bucket
- *   yield* Metric.update(responseTimeHistogram, 150) // Goes in 100-250ms bucket
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *   const value = yield* Metric.value(responseTimeHistogram)
- *   return value
- * })
+ * Metric.boundariesFromIterable([-5, 0, 10, 10, 25, 50]) // => [10, 25, 50, Infinity]
  * ```
  *
- * @category boundaries
+ * @category constructors
  * @since 4.0.0
  */
 export const boundariesFromIterable = iterable => Arr.append(Arr.filter(new Set(iterable), n => n > 0), Number.POSITIVE_INFINITY);
@@ -1559,49 +1443,23 @@ export const boundariesFromIterable = iterable => Arr.append(Arr.filter(new Set(
  *
  * **Details**
  *
- * Generates `count - 1` finite boundaries using `start + width + index` for
+ * Generates `count - 1` candidate boundaries using `start + index * width` for
  * each zero-based index, then applies the same normalization as
  * `boundariesFromIterable`: non-positive values are removed, duplicates are
  * collapsed, and `Infinity` is appended.
  *
  * **Example** (Creating linear boundaries)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class BoundaryError extends Data.TaggedError("BoundaryError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Create boundaries for response time histogram
- * const responseBoundaries = Metric.linearBoundaries({
- *   start: 0, // Starting point
- *   width: 100, // Offset used for the first boundary
- *   count: 5 // Creates 4 boundaries + infinity
- * })
- * console.log(responseBoundaries) // [100, 101, 102, 103, Infinity]
- *
- * // Create a histogram using these boundaries
- * const responseTimeHistogram = Metric.histogram("api_response_time", {
- *   description: "API response time distribution",
- *   boundaries: responseBoundaries
- * })
- *
- * const program = Effect.gen(function*() {
- *   // Record some response times
- *   yield* Metric.update(responseTimeHistogram, 85)
- *   yield* Metric.update(responseTimeHistogram, 101)
- *   yield* Metric.update(responseTimeHistogram, 450)
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *   const value = yield* Metric.value(responseTimeHistogram)
- *   return value
- * })
+ * Metric.linearBoundaries({ start: 10, width: 20, count: 5 }) // => [10, 30, 50, 70, Infinity]
  * ```
  *
- * @category boundaries
+ * @category constructors
  * @since 4.0.0
  */
-export const linearBoundaries = options => boundariesFromIterable(Arr.makeBy(options.count - 1, n => options.start + n + options.width));
+export const linearBoundaries = options => boundariesFromIterable(Arr.makeBy(options.count - 1, n => options.start + n * options.width));
 /**
  * Creates histogram bucket boundaries with exponentially increasing values.
  *
@@ -1612,47 +1470,13 @@ export const linearBoundaries = options => boundariesFromIterable(Arr.makeBy(opt
  *
  * **Example** (Creating exponential boundaries)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class BoundaryError extends Data.TaggedError("BoundaryError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Create exponential boundaries for request size histogram
- * // Buckets: 0-1KB, 1-2KB, 2-4KB, 4-8KB, 8KB+
- * const sizeBoundaries = Metric.exponentialBoundaries({
- *   start: 1, // Starting at 1KB
- *   factor: 2, // Each boundary doubles the previous
- *   count: 5 // Creates 4 boundaries + infinity
- * })
- * console.log(sizeBoundaries) // [1, 2, 4, 8, Infinity]
- *
- * // Create a histogram for tracking request payload sizes
- * const requestSizeHistogram = Metric.histogram("request_size_kb", {
- *   description: "Request payload size distribution in KB",
- *   boundaries: sizeBoundaries
- * })
- *
- * // For very wide ranges, use larger factors
- * const latencyBoundaries = Metric.exponentialBoundaries({
- *   start: 0.1, // Start at 0.1ms
- *   factor: 10, // Each boundary is 10x larger
- *   count: 6 // Creates ranges: 0.1ms, 1ms, 10ms, 100ms, 1000ms+
- * })
- *
- * const program = Effect.gen(function*() {
- *   // Record different request sizes
- *   yield* Metric.update(requestSizeHistogram, 1.5) // Goes in 1-2KB bucket
- *   yield* Metric.update(requestSizeHistogram, 3.2) // Goes in 2-4KB bucket
- *   yield* Metric.update(requestSizeHistogram, 12) // Goes in 8KB+ bucket
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *   const value = yield* Metric.value(requestSizeHistogram)
- *   return value
- * })
+ * Metric.exponentialBoundaries({ start: 1, factor: 2, count: 5 }) // => [1, 2, 4, 8, Infinity]
  * ```
  *
- * @category boundaries
+ * @category constructors
  * @since 4.0.0
  */
 export const exponentialBoundaries = options => boundariesFromIterable(Arr.makeBy(options.count - 1, i => options.start * Math.pow(options.factor, i)));
@@ -1677,36 +1501,13 @@ const fiberFailures = /*#__PURE__*/counter("child_fiber_failures", {
  *
  * **Example** (Accessing the fiber runtime metrics key)
  *
- * ```ts
- * import { Data, Effect, Layer, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
- *
- * const program = Effect.gen(function*() {
- *   // The key is used internally by the Effect runtime to manage fiber metrics
- *   const key = Metric.FiberRuntimeMetricsKey
- *   console.log("Fiber metrics key:", key)
- *
- *   // Enable runtime metrics using the key
- *   const layer = Layer.succeed(Metric.FiberRuntimeMetrics)(
- *     Metric.FiberRuntimeMetricsImpl
- *   )
- *
- *   return yield* Effect.gen(function*() {
- *     // This Effect will have fiber metrics automatically collected
- *     yield* Effect.sleep("100 millis")
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *     // Create a test counter to demonstrate the key usage
- *     const testCounter = Metric.counter("test_counter")
- *     yield* Metric.update(testCounter, 1)
- *     return yield* Metric.value(testCounter)
- *   }).pipe(Effect.provide(layer))
- * })
+ * Metric.FiberRuntimeMetricsKey // => "effect/observability/Metric/FiberRuntimeMetricsKey"
  * ```
  *
- * @category metrics
+ * @category constants
  * @since 4.0.0
  */
 export const FiberRuntimeMetricsKey = InternalMetric.FiberRuntimeMetricsKey;
@@ -1727,48 +1528,25 @@ export const FiberRuntimeMetricsKey = InternalMetric.FiberRuntimeMetricsKey;
  *
  * **Example** (Accessing the fiber runtime metrics service)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // Access the fiber runtime metrics service
  *   const metricsService = yield* Metric.FiberRuntimeMetrics
- *
- *   if (metricsService) {
- *     console.log("Runtime metrics are enabled")
- *   } else {
- *     console.log("Runtime metrics are disabled")
- *   }
- *
- *   // Enable runtime metrics for the application
- *   const enabledLayer = Metric.enableRuntimeMetricsLayer
- *
- *   return yield* Effect.gen(function*() {
- *     // Create some concurrent fibers to see metrics in action
- *     yield* Effect.all([
- *       Effect.sleep("100 millis"),
- *       Effect.sleep("200 millis"),
- *       Effect.sleep("300 millis")
- *     ], { concurrency: "unbounded" })
- *
- *     // Create test metrics to demonstrate the service
- *     const testCounter = Metric.counter("test_counter")
- *     yield* Metric.update(testCounter, 5)
- *     const counterValue = yield* Metric.value(testCounter)
- *
- *     return { counterValue, metricsEnabled: true }
- *   }).pipe(Effect.provide(enabledLayer))
+ *   return metricsService === Metric.FiberRuntimeMetricsImpl
  * })
+ *
+ * const result = await Effect.runPromise(
+ *   Effect.provideService(program, Metric.FiberRuntimeMetrics, Metric.FiberRuntimeMetricsImpl)
+ * )
+ * const isDefault = result // => true
  * ```
  *
- * @category runtime metrics
+ * @category services
  * @since 4.0.0
  */
 export const FiberRuntimeMetrics = /*#__PURE__*/Context.Reference(InternalMetric.FiberRuntimeMetricsKey, {
+  fiberCached: true,
   defaultValue: constUndefined
 });
 /**
@@ -1776,44 +1554,16 @@ export const FiberRuntimeMetrics = /*#__PURE__*/Context.Reference(InternalMetric
  *
  * **Example** (Accessing the default fiber metrics implementation)
  *
- * ```ts
- * import { Data, Effect, Layer, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
- *
- * const program = Effect.gen(function*() {
- *   // Use the default metrics implementation
- *   const metrics = Metric.FiberRuntimeMetricsImpl
- *   console.log("Metrics implementation:", metrics)
- *
- *   // Enable runtime metrics using the default implementation
- *   const layer = Layer.succeed(Metric.FiberRuntimeMetrics)(metrics)
- *
- *   return yield* Effect.gen(function*() {
- *     // Run some Effects to trigger metric collection
- *     yield* Effect.forkChild(Effect.sleep("50 millis"))
- *     yield* Effect.forkChild(Effect.sleep("100 millis"))
- *
- *     // Wait a bit and check the metrics
- *     yield* Effect.sleep("200 millis")
- *
- *     // Create test metrics to demonstrate the implementation
- *     const testCounter = Metric.counter("test_counter")
- *     const testGauge = Metric.gauge("test_gauge")
- *     yield* Metric.update(testCounter, 3)
- *     yield* Metric.update(testGauge, 42)
- *
- *     const counterValue = yield* Metric.value(testCounter)
- *     const gaugeValue = yield* Metric.value(testGauge)
+ * ```ts import.meta.vitest
+ * import { Metric } from "effect"
  *
- *     return { counter: counterValue, gauge: gaugeValue }
- *   }).pipe(Effect.provide(layer))
- * })
+ * [
+ *   typeof Metric.FiberRuntimeMetricsImpl.recordFiberStart,
+ *   typeof Metric.FiberRuntimeMetricsImpl.recordFiberEnd
+ * ] // => ["function", "function"]
  * ```
  *
- * @category metrics
+ * @category services
  * @since 4.0.0
  */
 export const FiberRuntimeMetricsImpl = {
@@ -1841,91 +1591,18 @@ export const FiberRuntimeMetricsImpl = {
  *
  * **Example** (Enabling runtime metrics with a layer)
  *
- * ```ts
- * import { Console, Data, Effect, Layer, Metric } from "effect"
- *
- * class AppError extends Data.TaggedError("AppError")<{
- *   readonly operation: string
- * }> {}
- *
- * // Define your application logic
- * const userService = Effect.gen(function*() {
- *   // Simulate user operations with concurrent processing
- *   const fetchUser = (id: number) =>
- *     Effect.gen(function*() {
- *       yield* Effect.sleep(`${50 + id * 10} millis`)
- *       if (id % 7 === 0) {
- *         return yield* new AppError({ operation: `fetch-user-${id}` })
- *       }
- *       return { id, name: `User ${id}`, email: `user${id}@example.com` }
- *     })
- *
- *   // Process multiple users concurrently (ignoring failures for demo)
- *   const userIds = Array.from({ length: 10 }, (_, i) => i + 1)
- *   const userTasks = userIds.map((id) =>
- *     fetchUser(id).pipe(Effect.catchTag("AppError", () => Effect.succeed(null)))
- *   )
- *   const allUsers = yield* Effect.all(userTasks, { concurrency: 4 })
- *   const successfulUsers = allUsers.filter((user) => user !== null)
- *   return successfulUsers
- * })
- *
- * const analyticsService = Effect.gen(function*() {
- *   // Simulate analytics processing
- *   const tasks = Array.from({ length: 8 }, (_, i) =>
- *     Effect.gen(function*() {
- *       yield* Effect.sleep(`${100 + i * 25} millis`)
- *       return `Analytics task ${i} completed`
- *     }))
- *   return yield* Effect.all(tasks, { concurrency: 3 })
- * })
- *
- * // Main application that uses multiple services
- * const application = Effect.gen(function*() {
- *   yield* Console.log("Starting application with runtime metrics...")
- *
- *   // Run services concurrently
- *   const [users, analytics] = yield* Effect.all([
- *     userService,
- *     analyticsService
- *   ], { concurrency: 2 })
- *
- *   yield* Console.log(
- *     `Processed ${users.length} users and ${analytics.length} analytics tasks`
- *   )
- *
- *   // Inspect the automatically collected runtime metrics
- *   const metrics = yield* Metric.snapshot
- *   const runtimeMetrics = metrics.filter((m) => m.id.startsWith("child_fiber"))
- *
- *   yield* Console.log("Runtime Metrics Collected:")
- *   for (const metric of runtimeMetrics) {
- *     yield* Console.log(`  ${metric.id}: ${JSON.stringify(metric.state)}`)
- *   }
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
- *   return { users, analytics, metricsCount: runtimeMetrics.length }
+ * const program = Effect.gen(function*() {
+ *   const service = yield* Metric.FiberRuntimeMetrics
+ *   return service === Metric.FiberRuntimeMetricsImpl
  * })
  *
- * // Create the base application layer
- * const AppLayer = Layer.empty // Add your application layers here (database, HTTP, etc.)
- *
- * // Add runtime metrics layer at the end
- * const AppLayerWithMetrics = AppLayer.pipe(
- *   Layer.provide(Metric.enableRuntimeMetricsLayer)
- * )
- *
- * // Run the application with runtime metrics enabled
- * const program = application.pipe(
- *   Effect.provide(AppLayerWithMetrics)
- * )
- *
- * // Alternative: Provide runtime metrics directly to the application
- * const programWithDirectMetrics = application.pipe(
- *   Effect.provide(Metric.enableRuntimeMetricsLayer)
- * )
+ * await Effect.runPromise(Effect.provide(program, Metric.enableRuntimeMetricsLayer)) // => true
  * ```
  *
- * @category metrics
+ * @category layers
  * @since 4.0.0
  */
 export const enableRuntimeMetricsLayer = /*#__PURE__*/Layer.succeed(FiberRuntimeMetrics)(FiberRuntimeMetricsImpl);
@@ -1934,12 +1611,8 @@ export const enableRuntimeMetricsLayer = /*#__PURE__*/Layer.succeed(FiberRuntime
  *
  * **Example** (Disabling runtime metrics with a layer)
  *
- * ```ts
- * import { Data, Effect, Metric } from "effect"
- *
- * class MetricsError extends Data.TaggedError("MetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
  *   // Disable runtime metrics collection
@@ -1948,7 +1621,6 @@ export const enableRuntimeMetricsLayer = /*#__PURE__*/Layer.succeed(FiberRuntime
  *   return yield* Effect.gen(function*() {
  *     // Check that metrics service is disabled
  *     const metricsService = yield* Metric.FiberRuntimeMetrics
- *     console.log("Metrics enabled:", metricsService !== undefined) // false
  *
  *     // Run some Effects - no metrics will be collected
  *     yield* Effect.forkChild(Effect.sleep("50 millis"))
@@ -1963,9 +1635,12 @@ export const enableRuntimeMetricsLayer = /*#__PURE__*/Layer.succeed(FiberRuntime
  *     return { counterValue, metricsEnabled: metricsService !== undefined }
  *   }).pipe(Effect.provide(disabledLayer))
  * })
+ *
+ * const result = await Effect.runPromise(Effect.provideService(program, Metric.MetricRegistry, new Map()))
+ * const values = [result.counterValue.count, result.metricsEnabled] // => [1, false]
  * ```
  *
- * @category metrics
+ * @category layers
  * @since 4.0.0
  */
 export const disableRuntimeMetricsLayer = /*#__PURE__*/Layer.succeed(FiberRuntimeMetrics)(undefined);
@@ -1980,75 +1655,18 @@ export const disableRuntimeMetricsLayer = /*#__PURE__*/Layer.succeed(FiberRuntim
  *
  * **Example** (Enabling runtime metrics for an effect)
  *
- * ```ts
- * import { Console, Data, Effect, Layer, Metric } from "effect"
- *
- * class RuntimeMetricsError extends Data.TaggedError("RuntimeMetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // Create a concurrent workload to demonstrate fiber metrics
- *   const heavyWorkload = Effect.gen(function*() {
- *     // Simulate concurrent operations
- *     const tasks = Array.from({ length: 10 }, (_, i) =>
- *       Effect.gen(function*() {
- *         yield* Effect.sleep(`${100 + i * 50} millis`)
- *         if (i % 4 === 0) {
- *           // Simulate some failures
- *           return yield* new RuntimeMetricsError({ operation: `task-${i}` })
- *         }
- *         return `Task ${i} completed`
- *       }).pipe(
- *         Effect.catchTag("RuntimeMetricsError", () =>
- *           Effect.succeed(`Task ${i} failed`))
- *       ))
- *
- *     // Run tasks concurrently
- *     const results = yield* Effect.all(tasks, { concurrency: 5 })
- *     return results
- *   })
- *
- *   // Enable runtime metrics collection for our workload
- *   const workloadWithMetrics = Metric.enableRuntimeMetrics(heavyWorkload)
- *
- *   // Execute the workload
- *   const results = yield* workloadWithMetrics
- *
- *   // After execution, we can inspect the runtime metrics
- *   // The following metrics are automatically collected:
- *   // - child_fibers_active: Current number of active child fibers (Gauge)
- *   // - child_fibers_started: Total child fibers started (Counter, incremental)
- *   // - child_fiber_successes: Total successful child fibers (Counter, incremental)
- *   // - child_fiber_failures: Total failed child fibers (Counter, incremental)
- *
- *   yield* Console.log(`Workload completed with ${results.length} results`)
- *
- *   // Get all metrics including the runtime metrics
- *   const allMetrics = yield* Metric.snapshot
- *   const runtimeMetrics = allMetrics.filter((m) =>
- *     m.id.startsWith("child_fiber") || m.id.includes("fiber")
- *   )
- *
- *   yield* Console.log("Runtime Metrics:")
- *   for (const metric of runtimeMetrics) {
- *     yield* Console.log(`  ${metric.id}: ${JSON.stringify(metric.state)}`)
- *   }
- *
- *   return results
+ *   const service = yield* Metric.FiberRuntimeMetrics
+ *   return service === Metric.FiberRuntimeMetricsImpl
  * })
  *
- * // Alternative: Use the layer version for broader application coverage
- * const BaseAppLayer = Layer.empty // Your base application layers
- * const AppLayerWithMetrics = BaseAppLayer.pipe(
- *   Layer.provide(Metric.enableRuntimeMetricsLayer)
- * )
- * const programWithLayer = program.pipe(
- *   Effect.provide(AppLayerWithMetrics)
- * )
+ * await Effect.runPromise(Metric.enableRuntimeMetrics(program)) // => true
  * ```
  *
- * @category metrics
+ * @category providing services
  * @since 4.0.0
  */
 export const enableRuntimeMetrics = /*#__PURE__*/InternalEffect.provideService(FiberRuntimeMetrics, FiberRuntimeMetricsImpl);
@@ -2062,76 +1680,18 @@ export const enableRuntimeMetrics = /*#__PURE__*/InternalEffect.provideService(F
  *
  * **Example** (Disabling runtime metrics for an effect)
  *
- * ```ts
- * import { Console, Data, Effect, Layer, Metric } from "effect"
- *
- * class DisableMetricsError extends Data.TaggedError("DisableMetricsError")<{
- *   readonly operation: string
- * }> {}
+ * ```ts import.meta.vitest
+ * import { Effect, Metric } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   // This section will have runtime metrics enabled
- *   const normalOperation = Effect.gen(function*() {
- *     const tasks = Array.from({ length: 5 }, (_, i) =>
- *       Effect.gen(function*() {
- *         yield* Effect.sleep(`${100 + i * 20} millis`)
- *         return `Normal task ${i} completed`
- *       }))
- *     return yield* Effect.all(tasks, { concurrency: 3 })
- *   })
- *
- *   // This section will have runtime metrics disabled for performance
- *   const highPerformanceOperation = Metric.disableRuntimeMetrics(
- *     Effect.gen(function*() {
- *       // Performance-critical code where metrics overhead should be avoided
- *       const hotPath = Array.from(
- *         { length: 1000 },
- *         (_, i) =>
- *           Effect.gen(function*() {
- *             // Simulate intensive computation
- *             const result = i * i + (i % 10) / 10
- *             return result
- *           })
- *       )
- *       return yield* Effect.all(hotPath, { concurrency: 100 })
- *     })
- *   )
- *
- *   yield* Console.log("Running operations with selective metrics...")
- *
- *   // Run both operations
- *   const [normalResults, performanceResults] = yield* Effect.all([
- *     normalOperation, // Will generate fiber metrics
- *     highPerformanceOperation // Will NOT generate fiber metrics
- *   ])
- *
- *   // Check collected metrics - should only see metrics from normalOperation
- *   const metrics = yield* Metric.snapshot
- *   const runtimeMetrics = metrics.filter((m) => m.id.startsWith("child_fiber"))
- *
- *   yield* Console.log(`Normal operation results: ${normalResults.length}`)
- *   yield* Console.log(
- *     `Performance operation results: ${performanceResults.length}`
- *   )
- *   yield* Console.log(`Runtime metrics collected: ${runtimeMetrics.length}`)
- *
- *   // The runtime metrics will only reflect the fibers from normalOperation
- *   // The highPerformanceOperation fibers were not tracked due to disableRuntimeMetrics
- *
- *   return { normalResults, performanceResults, runtimeMetrics }
+ *   const service = yield* Metric.FiberRuntimeMetrics
+ *   return service === undefined
  * })
  *
- * // Enable runtime metrics globally, then selectively disable where needed
- * const BaseAppLayer = Layer.empty // Your base application layers
- * const AppLayerWithMetrics = BaseAppLayer.pipe(
- *   Layer.provide(Metric.enableRuntimeMetricsLayer)
- * )
- * const finalProgram = program.pipe(
- *   Effect.provide(AppLayerWithMetrics)
- * )
+ * await Effect.runPromise(Metric.disableRuntimeMetrics(program)) // => true
  * ```
  *
- * @category metrics
+ * @category providing services
  * @since 4.0.0
  */
 export const disableRuntimeMetrics = /*#__PURE__*/InternalEffect.provideService(FiberRuntimeMetrics, undefined);
@@ -2154,10 +1714,7 @@ function makeHooks(get, update, modify) {
   };
 }
 function serializeAttributes(attributes) {
-  return serializeEntries(Array.isArray(attributes) ? attributes : Object.entries(attributes));
-}
-function serializeEntries(entries) {
-  return entries.map(([key, value]) => `${key}=${value}`).join(",");
+  return JSON.stringify(Array.isArray(attributes) ? attributes : Object.entries(attributes));
 }
 function mergeAttributes(self, other) {
   return {
@@ -2168,7 +1725,7 @@ function mergeAttributes(self, other) {
 function attributesToRecord(attributes) {
   if (Predicate.isNotUndefined(attributes) && Array.isArray(attributes)) {
     return attributes.reduce((acc, [key, value]) => {
-      acc[key] = value;
+      InternalRecord.assignProperty(acc, key, value);
       return acc;
     }, {});
   }