@effect/opentelemetry 0.13.1 → 0.15.0

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/Metrics.js";
+//# sourceMappingURL=effect-opentelemetry-Metrics.cjs.d.mts.map

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-opentelemetry-Metrics.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/Metrics.d.ts"],"names":[],"mappings":"AAAA"}

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/Metrics";
+//# sourceMappingURL=effect-opentelemetry-Metrics.cjs.d.ts.map

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-opentelemetry-Metrics.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/Metrics.d.ts"],"names":[],"mappings":"AAAA"}

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.dev.js

@@ -0,0 +1,293 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var OtelApi = require('@opentelemetry/api');
+var sdkMetrics = require('@opentelemetry/sdk-metrics');
+var Effect = require('effect/Effect');
+var HashSet = require('effect/HashSet');
+var Layer = require('effect/Layer');
+var Metric = require('effect/Metric');
+var MetricKeyType = require('effect/MetricKeyType');
+var MetricState = require('effect/MetricState');
+var Option = require('effect/Option');
+var Resource_dist_effectOpentelemetryResource = require('../../Resource/dist/effect-opentelemetry-Resource.cjs.dev.js');
+require('@opentelemetry/resources');
+require('@opentelemetry/semantic-conventions');
+require('effect/Context');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var HashSet__namespace = /*#__PURE__*/_interopNamespace(HashSet);
+var Layer__namespace = /*#__PURE__*/_interopNamespace(Layer);
+var Metric__namespace = /*#__PURE__*/_interopNamespace(Metric);
+var MetricKeyType__namespace = /*#__PURE__*/_interopNamespace(MetricKeyType);
+var MetricState__namespace = /*#__PURE__*/_interopNamespace(MetricState);
+var Option__namespace = /*#__PURE__*/_interopNamespace(Option);
+
+const sdkName = "@effect/opentelemetry/Metrics";
+
+/** @internal */
+class MetricProducerImpl {
+  constructor(resource) {
+    this.resource = resource;
+  }
+  collect(_options) {
+    const snapshot = Metric__namespace.unsafeSnapshot();
+    const hrTimeNow = currentHrTime();
+    const metricData = [];
+    for (const {
+      metricKey,
+      metricState
+    } of snapshot) {
+      const attributes = HashSet__namespace.reduce(metricKey.tags, {}, (acc, label) => {
+        acc[label.key] = label.value;
+        return acc;
+      });
+      const descriptor = descriptorFromKey(metricKey, attributes);
+      if (MetricState__namespace.isCounterState(metricState)) {
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor,
+          isMonotonic: descriptor.type === sdkMetrics.InstrumentType.COUNTER,
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: Number(metricState.count)
+          }]
+        });
+      } else if (MetricState__namespace.isGaugeState(metricState)) {
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.GAUGE,
+          descriptor,
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: Number(metricState.value)
+          }]
+        });
+      } else if (MetricState__namespace.isHistogramState(metricState)) {
+        const size = metricState.buckets.length;
+        const buckets = {
+          boundaries: Array(size - 1),
+          counts: Array(size)
+        };
+        let i = 0;
+        let prev = 0;
+        for (const [boundary, value] of metricState.buckets) {
+          if (i < size - 1) {
+            buckets.boundaries[i] = boundary;
+          }
+          buckets.counts[i] = value - prev;
+          prev = value;
+          i++;
+        }
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.HISTOGRAM,
+          descriptor,
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: {
+              buckets,
+              count: metricState.count,
+              min: metricState.min,
+              max: metricState.max,
+              sum: metricState.sum
+            }
+          }]
+        });
+      } else if (MetricState__namespace.isFrequencyState(metricState)) {
+        const dataPoints = [];
+        for (const [freqKey, value] of metricState.occurrences) {
+          dataPoints.push({
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes: {
+              ...attributes,
+              key: freqKey
+            },
+            value
+          });
+        }
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: descriptorFromKey(metricKey, attributes),
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints
+        });
+      } else if (MetricState__namespace.isSummaryState(metricState)) {
+        const dataPoints = [{
+          startTime: hrTimeNow,
+          endTime: hrTimeNow,
+          attributes: {
+            ...attributes,
+            quantile: "min"
+          },
+          value: metricState.min
+        }];
+        for (const [quantile, value] of metricState.quantiles) {
+          dataPoints.push({
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes: {
+              ...attributes,
+              quantile: quantile.toString()
+            },
+            value: value._tag === "Some" ? value.value : 0
+          });
+        }
+        dataPoints.push({
+          startTime: hrTimeNow,
+          endTime: hrTimeNow,
+          attributes: {
+            ...attributes,
+            quantile: "max"
+          },
+          value: metricState.max
+        });
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: descriptorFromKey(metricKey, attributes, "quantiles"),
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: false,
+          dataPoints
+        });
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: {
+            ...descriptorMeta(metricKey, "count"),
+            unit: "1",
+            type: sdkMetrics.InstrumentType.COUNTER,
+            valueType: OtelApi.ValueType.INT
+          },
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.count
+          }]
+        });
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: {
+            ...descriptorMeta(metricKey, "sum"),
+            unit: "1",
+            type: sdkMetrics.InstrumentType.COUNTER,
+            valueType: OtelApi.ValueType.DOUBLE
+          },
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.sum
+          }]
+        });
+      }
+    }
+    return Promise.resolve({
+      resourceMetrics: {
+        resource: this.resource,
+        scopeMetrics: [{
+          scope: {
+            name: sdkName
+          },
+          metrics: metricData
+        }]
+      },
+      errors: []
+    });
+  }
+}
+const descriptorMeta = (metricKey, suffix) => ({
+  name: suffix ? `${metricKey.name}_${suffix}` : metricKey.name,
+  description: Option__namespace.getOrElse(metricKey.description, () => "")
+});
+const descriptorFromKey = (metricKey, tags, suffix) => ({
+  ...descriptorMeta(metricKey, suffix),
+  unit: tags.unit ?? tags.time_unit ?? "1",
+  type: instrumentTypeFromKey(metricKey),
+  valueType: "bigint" in metricKey.keyType && metricKey.keyType.bigint === true ? OtelApi.ValueType.INT : OtelApi.ValueType.DOUBLE
+});
+const instrumentTypeFromKey = key => {
+  if (MetricKeyType__namespace.isHistogramKey(key.keyType)) {
+    return sdkMetrics.InstrumentType.HISTOGRAM;
+  } else if (MetricKeyType__namespace.isGaugeKey(key.keyType)) {
+    return sdkMetrics.InstrumentType.OBSERVABLE_GAUGE;
+  } else if (MetricKeyType__namespace.isFrequencyKey(key.keyType)) {
+    return sdkMetrics.InstrumentType.COUNTER;
+  } else if (MetricKeyType__namespace.isCounterKey(key.keyType) && key.keyType.incremental) {
+    return sdkMetrics.InstrumentType.COUNTER;
+  }
+  return sdkMetrics.InstrumentType.UP_DOWN_COUNTER;
+};
+const currentHrTime = () => {
+  const now = Date.now();
+  return [Math.floor(now / 1000), now % 1000 * 1000000];
+};
+
+/** @internal */
+const makeProducer$1 = /*#__PURE__*/Effect__namespace.map(Resource_dist_effectOpentelemetryResource.Resource, resource => new MetricProducerImpl(resource));
+
+/** @internal */
+const registerProducer$1 = (self, metricReader) => Effect__namespace.acquireRelease(Effect__namespace.sync(() => {
+  const reader = metricReader();
+  reader.setMetricProducer(self);
+  return reader;
+}), reader => Effect__namespace.promise(() => reader.shutdown()));
+
+/** @internal */
+const layer$1 = evaluate => Layer__namespace.scopedDiscard(Effect__namespace.flatMap(makeProducer$1, producer => registerProducer$1(producer, evaluate)));
+
+/**
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ * @category producer
+ */
+const makeProducer = makeProducer$1;
+
+/**
+ * @since 1.0.0
+ * @category producer
+ */
+const registerProducer = registerProducer$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layer = layer$1;
+
+exports.layer = layer;
+exports.makeProducer = makeProducer;
+exports.registerProducer = registerProducer;

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./effect-opentelemetry-Metrics.cjs.prod.js");
+} else {
+  module.exports = require("./effect-opentelemetry-Metrics.cjs.dev.js");
+}

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.mjs

@@ -0,0 +1,5 @@
+export {
+  layer,
+  makeProducer,
+  registerProducer
+} from "./effect-opentelemetry-Metrics.cjs.js";

package/Metrics/dist/effect-opentelemetry-Metrics.cjs.prod.js

@@ -0,0 +1,293 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var OtelApi = require('@opentelemetry/api');
+var sdkMetrics = require('@opentelemetry/sdk-metrics');
+var Effect = require('effect/Effect');
+var HashSet = require('effect/HashSet');
+var Layer = require('effect/Layer');
+var Metric = require('effect/Metric');
+var MetricKeyType = require('effect/MetricKeyType');
+var MetricState = require('effect/MetricState');
+var Option = require('effect/Option');
+var Resource_dist_effectOpentelemetryResource = require('../../Resource/dist/effect-opentelemetry-Resource.cjs.prod.js');
+require('@opentelemetry/resources');
+require('@opentelemetry/semantic-conventions');
+require('effect/Context');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var HashSet__namespace = /*#__PURE__*/_interopNamespace(HashSet);
+var Layer__namespace = /*#__PURE__*/_interopNamespace(Layer);
+var Metric__namespace = /*#__PURE__*/_interopNamespace(Metric);
+var MetricKeyType__namespace = /*#__PURE__*/_interopNamespace(MetricKeyType);
+var MetricState__namespace = /*#__PURE__*/_interopNamespace(MetricState);
+var Option__namespace = /*#__PURE__*/_interopNamespace(Option);
+
+const sdkName = "@effect/opentelemetry/Metrics";
+
+/** @internal */
+class MetricProducerImpl {
+  constructor(resource) {
+    this.resource = resource;
+  }
+  collect(_options) {
+    const snapshot = Metric__namespace.unsafeSnapshot();
+    const hrTimeNow = currentHrTime();
+    const metricData = [];
+    for (const {
+      metricKey,
+      metricState
+    } of snapshot) {
+      const attributes = HashSet__namespace.reduce(metricKey.tags, {}, (acc, label) => {
+        acc[label.key] = label.value;
+        return acc;
+      });
+      const descriptor = descriptorFromKey(metricKey, attributes);
+      if (MetricState__namespace.isCounterState(metricState)) {
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor,
+          isMonotonic: descriptor.type === sdkMetrics.InstrumentType.COUNTER,
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: Number(metricState.count)
+          }]
+        });
+      } else if (MetricState__namespace.isGaugeState(metricState)) {
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.GAUGE,
+          descriptor,
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: Number(metricState.value)
+          }]
+        });
+      } else if (MetricState__namespace.isHistogramState(metricState)) {
+        const size = metricState.buckets.length;
+        const buckets = {
+          boundaries: Array(size - 1),
+          counts: Array(size)
+        };
+        let i = 0;
+        let prev = 0;
+        for (const [boundary, value] of metricState.buckets) {
+          if (i < size - 1) {
+            buckets.boundaries[i] = boundary;
+          }
+          buckets.counts[i] = value - prev;
+          prev = value;
+          i++;
+        }
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.HISTOGRAM,
+          descriptor,
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: {
+              buckets,
+              count: metricState.count,
+              min: metricState.min,
+              max: metricState.max,
+              sum: metricState.sum
+            }
+          }]
+        });
+      } else if (MetricState__namespace.isFrequencyState(metricState)) {
+        const dataPoints = [];
+        for (const [freqKey, value] of metricState.occurrences) {
+          dataPoints.push({
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes: {
+              ...attributes,
+              key: freqKey
+            },
+            value
+          });
+        }
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: descriptorFromKey(metricKey, attributes),
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints
+        });
+      } else if (MetricState__namespace.isSummaryState(metricState)) {
+        const dataPoints = [{
+          startTime: hrTimeNow,
+          endTime: hrTimeNow,
+          attributes: {
+            ...attributes,
+            quantile: "min"
+          },
+          value: metricState.min
+        }];
+        for (const [quantile, value] of metricState.quantiles) {
+          dataPoints.push({
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes: {
+              ...attributes,
+              quantile: quantile.toString()
+            },
+            value: value._tag === "Some" ? value.value : 0
+          });
+        }
+        dataPoints.push({
+          startTime: hrTimeNow,
+          endTime: hrTimeNow,
+          attributes: {
+            ...attributes,
+            quantile: "max"
+          },
+          value: metricState.max
+        });
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: descriptorFromKey(metricKey, attributes, "quantiles"),
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: false,
+          dataPoints
+        });
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: {
+            ...descriptorMeta(metricKey, "count"),
+            unit: "1",
+            type: sdkMetrics.InstrumentType.COUNTER,
+            valueType: OtelApi.ValueType.INT
+          },
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.count
+          }]
+        });
+        metricData.push({
+          dataPointType: sdkMetrics.DataPointType.SUM,
+          descriptor: {
+            ...descriptorMeta(metricKey, "sum"),
+            unit: "1",
+            type: sdkMetrics.InstrumentType.COUNTER,
+            valueType: OtelApi.ValueType.DOUBLE
+          },
+          aggregationTemporality: sdkMetrics.AggregationTemporality.CUMULATIVE,
+          isMonotonic: true,
+          dataPoints: [{
+            startTime: hrTimeNow,
+            endTime: hrTimeNow,
+            attributes,
+            value: metricState.sum
+          }]
+        });
+      }
+    }
+    return Promise.resolve({
+      resourceMetrics: {
+        resource: this.resource,
+        scopeMetrics: [{
+          scope: {
+            name: sdkName
+          },
+          metrics: metricData
+        }]
+      },
+      errors: []
+    });
+  }
+}
+const descriptorMeta = (metricKey, suffix) => ({
+  name: suffix ? `${metricKey.name}_${suffix}` : metricKey.name,
+  description: Option__namespace.getOrElse(metricKey.description, () => "")
+});
+const descriptorFromKey = (metricKey, tags, suffix) => ({
+  ...descriptorMeta(metricKey, suffix),
+  unit: tags.unit ?? tags.time_unit ?? "1",
+  type: instrumentTypeFromKey(metricKey),
+  valueType: "bigint" in metricKey.keyType && metricKey.keyType.bigint === true ? OtelApi.ValueType.INT : OtelApi.ValueType.DOUBLE
+});
+const instrumentTypeFromKey = key => {
+  if (MetricKeyType__namespace.isHistogramKey(key.keyType)) {
+    return sdkMetrics.InstrumentType.HISTOGRAM;
+  } else if (MetricKeyType__namespace.isGaugeKey(key.keyType)) {
+    return sdkMetrics.InstrumentType.OBSERVABLE_GAUGE;
+  } else if (MetricKeyType__namespace.isFrequencyKey(key.keyType)) {
+    return sdkMetrics.InstrumentType.COUNTER;
+  } else if (MetricKeyType__namespace.isCounterKey(key.keyType) && key.keyType.incremental) {
+    return sdkMetrics.InstrumentType.COUNTER;
+  }
+  return sdkMetrics.InstrumentType.UP_DOWN_COUNTER;
+};
+const currentHrTime = () => {
+  const now = Date.now();
+  return [Math.floor(now / 1000), now % 1000 * 1000000];
+};
+
+/** @internal */
+const makeProducer$1 = /*#__PURE__*/Effect__namespace.map(Resource_dist_effectOpentelemetryResource.Resource, resource => new MetricProducerImpl(resource));
+
+/** @internal */
+const registerProducer$1 = (self, metricReader) => Effect__namespace.acquireRelease(Effect__namespace.sync(() => {
+  const reader = metricReader();
+  reader.setMetricProducer(self);
+  return reader;
+}), reader => Effect__namespace.promise(() => reader.shutdown()));
+
+/** @internal */
+const layer$1 = evaluate => Layer__namespace.scopedDiscard(Effect__namespace.flatMap(makeProducer$1, producer => registerProducer$1(producer, evaluate)));
+
+/**
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ * @category producer
+ */
+const makeProducer = makeProducer$1;
+
+/**
+ * @since 1.0.0
+ * @category producer
+ */
+const registerProducer = registerProducer$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layer = layer$1;
+
+exports.layer = layer;
+exports.makeProducer = makeProducer;
+exports.registerProducer = registerProducer;

package/Metrics/dist/effect-opentelemetry-Metrics.esm.js

@@ -0,0 +1,24 @@
+import { makeProducer as makeProducer$1, registerProducer as registerProducer$1, layer as layer$1 } from '../../internal/metrics.esm.js';
+
+/**
+ * @since 1.0.0
+ */
+/**
+ * @since 1.0.0
+ * @category producer
+ */
+const makeProducer = makeProducer$1;
+
+/**
+ * @since 1.0.0
+ * @category producer
+ */
+const registerProducer = registerProducer$1;
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+const layer = layer$1;
+
+export { layer, makeProducer, registerProducer };

package/Metrics/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/effect-opentelemetry-Metrics.cjs.js",
+  "module": "dist/effect-opentelemetry-Metrics.esm.js"
+}

package/NodeSdk/dist/effect-opentelemetry-NodeSdk.cjs.d.mts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/NodeSdk.js";
+//# sourceMappingURL=effect-opentelemetry-NodeSdk.cjs.d.mts.map

package/NodeSdk/dist/effect-opentelemetry-NodeSdk.cjs.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-opentelemetry-NodeSdk.cjs.d.mts","sourceRoot":"","sources":["../../dist/declarations/src/NodeSdk.d.ts"],"names":[],"mappings":"AAAA"}

package/NodeSdk/dist/effect-opentelemetry-NodeSdk.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/NodeSdk";
+//# sourceMappingURL=effect-opentelemetry-NodeSdk.cjs.d.ts.map

package/NodeSdk/dist/effect-opentelemetry-NodeSdk.cjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-opentelemetry-NodeSdk.cjs.d.ts","sourceRoot":"","sources":["../../dist/declarations/src/NodeSdk.d.ts"],"names":[],"mappings":"AAAA"}