feat(effect): Add metrics to Sentry.effectLayer

packages/effect/src/client/index.ts

@@ -17,6 +17,7 @@ export type EffectClientLayerOptions = BrowserOptions;
  * This layer provides Effect applications with full Sentry instrumentation including:
  * - Effect spans traced as Sentry spans
  * - Effect logs forwarded to Sentry (when `enableLogs` is set)
+ * - Effect metrics sent to Sentry (when `enableMetrics` is set)
  *
  * @example
  * ```typescript

packages/effect/src/metrics.ts

@@ -0,0 +1,135 @@
+import { metrics as sentryMetrics } from '@sentry/core';
+import * as Effect from 'effect/Effect';
+import type * as Layer from 'effect/Layer';
+import { scopedDiscard } from 'effect/Layer';
+import * as Metric from 'effect/Metric';
+import * as MetricKeyType from 'effect/MetricKeyType';
+import type * as MetricPair from 'effect/MetricPair';
+import * as MetricState from 'effect/MetricState';
+import * as Schedule from 'effect/Schedule';
+
+type MetricAttributes = Record<string, string>;
+
+function labelsToAttributes(labels: ReadonlyArray<{ key: string; value: string }>): MetricAttributes {
+  return labels.reduce((acc, label) => ({ ...acc, [label.key]: label.value }), {});
+}
+
+function sendMetricToSentry(pair: MetricPair.MetricPair.Untyped): void {
+  const { metricKey, metricState } = pair;
+  const name = metricKey.name;
+  const attributes = labelsToAttributes(metricKey.tags);
+
+  if (MetricState.isCounterState(metricState)) {
+    const value = Number(metricState.count);
+    sentryMetrics.count(name, value, { attributes });
+  } else if (MetricState.isGaugeState(metricState)) {
+    const value = Number(metricState.value);
+    sentryMetrics.gauge(name, value, { attributes });
+  } else if (MetricState.isHistogramState(metricState)) {
+    sentryMetrics.gauge(`${name}.sum`, metricState.sum, { attributes });
+    sentryMetrics.gauge(`${name}.count`, metricState.count, { attributes });
+    sentryMetrics.gauge(`${name}.min`, metricState.min, { attributes });
+    sentryMetrics.gauge(`${name}.max`, metricState.max, { attributes });
+  } else if (MetricState.isSummaryState(metricState)) {
+    sentryMetrics.gauge(`${name}.sum`, metricState.sum, { attributes });
+    sentryMetrics.gauge(`${name}.count`, metricState.count, { attributes });
+    sentryMetrics.gauge(`${name}.min`, metricState.min, { attributes });
+    sentryMetrics.gauge(`${name}.max`, metricState.max, { attributes });
+  } else if (MetricState.isFrequencyState(metricState)) {
+    for (const [word, count] of metricState.occurrences) {
+      sentryMetrics.count(name, count, {
+        attributes: { ...attributes, word },
+      });
+    }
+  }
+}
+
+function getMetricId(pair: MetricPair.MetricPair.Untyped): string {
+  const tags = pair.metricKey.tags.map(t => `${t.key}=${t.value}`).join(',');
+  return `${pair.metricKey.name}:${tags}`;
+}
+
+function sendDeltaMetricToSentry(
+  pair: MetricPair.MetricPair.Untyped,
+  previousCounterValues: Map<string, number>,
+): void {
+  const { metricKey, metricState } = pair;
+  const name = metricKey.name;
+  const attributes = labelsToAttributes(metricKey.tags);
+  const metricId = getMetricId(pair);
+
+  if (MetricState.isCounterState(metricState)) {
+    const currentValue = Number(metricState.count);
+
+    const previousValue = previousCounterValues.get(metricId) ?? 0;
+    const delta = currentValue - previousValue;
+
+    if (delta > 0) {
+      sentryMetrics.count(name, delta, { attributes });
+    }
+
+    previousCounterValues.set(metricId, currentValue);
+  } else {
+    sendMetricToSentry(pair);
+  }
+}
+
+/**
+ * Flushes all Effect metrics to Sentry.
+ * @param previousCounterValues - Map tracking previous counter values for delta calculation
+ */
+function flushMetricsToSentry(previousCounterValues: Map<string, number>): void {
+  const snapshot = Metric.unsafeSnapshot();
+
+  snapshot.forEach((pair: MetricPair.MetricPair.Untyped) => {
+    if (MetricKeyType.isCounterKey(pair.metricKey.keyType)) {
+      sendDeltaMetricToSentry(pair, previousCounterValues);
+    } else {
+      sendMetricToSentry(pair);
+    }
+  });
+}
+
+/**
+ * Creates a metrics flusher with its own isolated state for delta tracking.
+ * Useful for testing scenarios where you need to control the lifecycle.
+ * @internal
+ */
+export function createMetricsFlusher(): {
+  flush: () => void;
+  clear: () => void;
+} {
+  const previousCounterValues = new Map<string, number>();
+  return {
+    flush: () => flushMetricsToSentry(previousCounterValues),
+    clear: () => previousCounterValues.clear(),
+  };
+}
+
+function createMetricsReporterEffect(previousCounterValues: Map<string, number>): Effect.Effect<void, never, never> {
+  const schedule = Schedule.spaced('10 seconds');
+
+  return Effect.repeat(
+    Effect.sync(() => flushMetricsToSentry(previousCounterValues)),
+    schedule,
+  ).pipe(Effect.asVoid, Effect.interruptible);
+}
+
+/**
+ * Effect Layer that periodically flushes metrics to Sentry.
+ * The layer manages its own state for delta counter calculations,
+ * which is automatically cleaned up when the layer is finalized.
+ */
+export const SentryEffectMetricsLayer: Layer.Layer<never, never, never> = scopedDiscard(
+  Effect.gen(function* () {
+    const previousCounterValues = new Map<string, number>();
+
+    yield* Effect.acquireRelease(Effect.void, () =>
+      Effect.sync(() => {
+        previousCounterValues.clear();
+      }),
+    );
+
+    yield* Effect.forkScoped(createMetricsReporterEffect(previousCounterValues));
+  }),
+);

packages/effect/src/server/index.ts

@@ -16,6 +16,7 @@ export type EffectServerLayerOptions = NodeOptions;
  * This layer provides Effect applications with full Sentry instrumentation including:
  * - Effect spans traced as Sentry spans
  * - Effect logs forwarded to Sentry (when `enableLogs` is set)
+ * - Effect metrics sent to Sentry (when `enableMetrics` is set)
  *
  * @example
  * ```typescript

packages/effect/src/utils/buildEffectLayer.ts

@@ -2,14 +2,16 @@ import type * as EffectLayer from 'effect/Layer';
 import { empty as emptyLayer, provideMerge } from 'effect/Layer';
 import { defaultLogger, replace as replaceLogger } from 'effect/Logger';
 import { SentryEffectLogger } from '../logger';
+import { SentryEffectMetricsLayer } from '../metrics';
 import { SentryEffectTracerLayer } from '../tracer';
 
 export interface EffectLayerBaseOptions {
   enableLogs?: boolean;
+  enableMetrics?: boolean;
 }
 
 /**
- * Builds an Effect layer that integrates Sentry tracing and logging.
+ * Builds an Effect layer that integrates Sentry tracing, logging, and metrics.
  *
  * Returns an empty layer if no Sentry client is available. Otherwise, starts with
  * the Sentry tracer layer and optionally merges logging and metrics layers based
@@ -23,13 +25,17 @@ export function buildEffectLayer<T extends EffectLayerBaseOptions>(
     return emptyLayer;
   }
 
-  const { enableLogs = false } = options;
+  const { enableLogs = false, enableMetrics = true } = options;
   let layer: EffectLayer.Layer<never, never, never> = SentryEffectTracerLayer;
 
   if (enableLogs) {
     const effectLogger = replaceLogger(defaultLogger, SentryEffectLogger);
     layer = layer.pipe(provideMerge(effectLogger));
   }
 
+  if (enableMetrics) {
+    layer = layer.pipe(provideMerge(SentryEffectMetricsLayer));
+  }
+
   return layer;
 }

packages/effect/test/buildEffectLayer.test.ts

@@ -48,8 +48,22 @@ describe('buildEffectLayer', () => {
       expect(Layer.isLayer(layer)).toBe(true);
     });
 
+    it('returns a valid layer with enableMetrics: false', () => {
+      const layer = buildEffectLayer({ enableMetrics: false }, mockClient);
+
+      expect(layer).toBeDefined();
+      expect(Layer.isLayer(layer)).toBe(true);
+    });
+
+    it('returns a valid layer with enableMetrics: true', () => {
+      const layer = buildEffectLayer({ enableMetrics: true }, mockClient);
+
+      expect(layer).toBeDefined();
+      expect(Layer.isLayer(layer)).toBe(true);
+    });
+
     it('returns a valid layer with all features enabled', () => {
-      const layer = buildEffectLayer({ enableLogs: true }, mockClient);
+      const layer = buildEffectLayer({ enableLogs: true, enableMetrics: true }, mockClient);
 
       expect(layer).toBeDefined();
       expect(Layer.isLayer(layer)).toBe(true);
@@ -71,20 +85,18 @@ describe('buildEffectLayer', () => {
       }).pipe(Effect.provide(buildEffectLayer({ enableLogs: true }, mockClient))),
     );
 
-    it.effect('layer with logs disabled routes Effect does not log to Sentry logger', () =>
-      Effect.gen(function* () {
-        const infoSpy = vi.spyOn(sentryLogger, 'info');
-        yield* Effect.log('test log message');
-        expect(infoSpy).not.toHaveBeenCalled();
-        infoSpy.mockRestore();
-      }).pipe(Effect.provide(buildEffectLayer({ enableLogs: false }, mockClient))),
-    );
+    it('returns different layer when enableMetrics is true vs false', () => {
+      const layerWithMetrics = buildEffectLayer({ enableMetrics: true }, mockClient);
+      const layerWithoutMetrics = buildEffectLayer({ enableMetrics: false }, mockClient);
+
+      expect(layerWithMetrics).not.toBe(layerWithoutMetrics);
+    });
 
     it.effect('layer with all features enabled can be provided to an Effect program', () =>
       Effect.gen(function* () {
         const result = yield* Effect.succeed('all-features');
         expect(result).toBe('all-features');
-      }).pipe(Effect.provide(buildEffectLayer({ enableLogs: true }, mockClient))),
+      }).pipe(Effect.provide(buildEffectLayer({ enableLogs: true, enableMetrics: true }, mockClient))),
     );
 
     it.effect('layer enables tracing for Effect spans via Sentry tracer', () =>
@@ -109,9 +121,10 @@ describe('buildEffectLayer', () => {
       const layer = buildEffectLayer(
         {
           enableLogs: true,
+          enableMetrics: true,
           dsn: 'https://test@sentry.io/123',
           debug: true,
-        } as { enableLogs?: boolean; dsn?: string; debug?: boolean },
+        } as { enableLogs?: boolean; enableMetrics?: boolean; dsn?: string; debug?: boolean },
         mockClient,
       );
 

packages/effect/test/layer.test.ts

@@ -74,6 +74,7 @@ describe.each([
       dsn: TEST_DSN,
       transport: getMockTransport(),
       enableLogs: true,
+      enableMetrics: true,
     });
 
     expect(layer).toBeDefined();