feat(node): Add Effect integration for tracing Effect computations

Co-Authored-By: Jan Peer Stöcklmair <jan.peer@sentry.io>

Author: Divyanshu7001

packages/node/src/index.ts

@@ -29,6 +29,7 @@ export { anthropicAIIntegration } from './integrations/tracing/anthropic-ai';
 export { googleGenAIIntegration } from './integrations/tracing/google-genai';
 export { langChainIntegration } from './integrations/tracing/langchain';
 export { langGraphIntegration } from './integrations/tracing/langgraph';
+export { effectIntegration } from './integrations/tracing/effect';
 export {
   launchDarklyIntegration,
   buildLaunchDarklyFlagUsedHandler,

packages/node/src/integrations/tracing/effect/effectIntegration.ts

@@ -0,0 +1,156 @@
+import type { IntegrationFn } from '@sentry/core';
+import { captureException, defineIntegration, getCurrentScope, startSpan, withScope } from '@sentry/core';
+import type { EffectExit, EffectModule, EffectSpan, EffectTracer } from './types';
+
+const INTEGRATION_NAME = 'Effect';
+
+// Global state to track if tracing is enabled
+let isInstrumentationEnabled = false;
+let originalTracer: EffectTracer | undefined;
+
+/**
+ * Instruments Effect spans to create Sentry spans.
+ */
+export const instrumentEffect = Object.assign(
+  (): void => {
+    if (isInstrumentationEnabled) {
+      return;
+    }
+
+    try {
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const Effect = require('effect') as EffectModule;
+
+      if (!Effect?.Tracer) {
+        return;
+      }
+
+      // Store the original tracer if it exists
+      originalTracer = Effect.Tracer.get?.() || Effect.Tracer.current?.() || undefined;
+
+      // Create our custom tracer that wraps operations in Sentry spans
+      const sentryTracer: EffectTracer = {
+        onSpanStart(span: EffectSpan) {
+          // Hook for span start - can be used for additional instrumentation
+          if (originalTracer?.onSpanStart) {
+            originalTracer.onSpanStart(span);
+          }
+        },
+
+        onSpanEnd(span: EffectSpan, exit: EffectExit) {
+          // Hook for span end - handle failures
+          if (exit._tag === 'Failure' && exit.cause) {
+            withScope(scope => {
+              scope.setTag('effect.exit_tag', exit._tag);
+              scope.setContext('effect.span', {
+                name: span.name,
+                startTime: Number(span.startTime),
+                endTime: span.endTime ? Number(span.endTime) : undefined,
+              });
+              captureException(exit.cause);
+            });
+          }
+
+          if (originalTracer?.onSpanEnd) {
+            originalTracer.onSpanEnd(span, exit);
+          }
+        },
+
+        span<A>(name: string, f: () => A): A {
+          return startSpan(
+            {
+              name,
+              op: 'effect.span',
+              origin: 'auto.effect',
+            },
+            () => {
+              try {
+                return f();
+              } catch (error) {
+                const scope = getCurrentScope();
+                scope.setTag('effect.error', true);
+                captureException(error);
+                throw error;
+              }
+            },
+          );
+        },
+
+        withSpan<A>(span: EffectSpan, f: () => A): A {
+          return startSpan(
+            {
+              name: span.name,
+              op: 'effect.span',
+              origin: 'auto.effect',
+              startTime: Number(span.startTime) / 1000000, // Convert nanoseconds to milliseconds
+              data: span.attributes,
+            },
+            sentrySpan => {
+              try {
+                const result = f();
+
+                // Set status based on span status
+                if (span.status && span.status.code !== 0) {
+                  sentrySpan.setStatus('internal_error');
+                  if (span.status.message) {
+                    sentrySpan.setData('effect.status_message', span.status.message);
+                  }
+                }
+
+                return result;
+              } catch (error) {
+                sentrySpan.setStatus('internal_error');
+                const scope = getCurrentScope();
+                scope.setTag('effect.error', true);
+                captureException(error);
+                throw error;
+              }
+            },
+          );
+        },
+      };
+
+      // Register our tracer with Effect
+      if (typeof Effect.Tracer.set === 'function') {
+        Effect.Tracer.set(sentryTracer);
+      } else if (typeof Effect.Tracer.register === 'function') {
+        Effect.Tracer.register(sentryTracer);
+      } else if (typeof Effect.Tracer.use === 'function') {
+        Effect.Tracer.use(sentryTracer);
+      } else {
+        return;
+      }
+
+      isInstrumentationEnabled = true;
+    } catch (error) {
+      // Silent failure - Effect may not be available
+    }
+  },
+  { id: INTEGRATION_NAME },
+);
+
+const _effectIntegration = (() => {
+  return {
+    name: INTEGRATION_NAME,
+    setupOnce() {
+      instrumentEffect();
+    },
+  };
+}) satisfies IntegrationFn;
+
+/**
+ * Adds Sentry tracing instrumentation for [Effect](https://effect.website/).
+ *
+ * This integration automatically traces Effect spans and captures errors that occur
+ * within Effect computations as Sentry exceptions with proper context.
+ *
+ * @example
+ * ```javascript
+ * const Sentry = require('@sentry/node');
+ *
+ * Sentry.init({
+ *   integrations: [Sentry.effectIntegration()],
+ * });
+ * ```
+ */
+export const effectIntegration = defineIntegration(_effectIntegration);

packages/node/src/integrations/tracing/effect/index.ts

@@ -0,0 +1 @@
+export { effectIntegration, instrumentEffect } from './effectIntegration';

packages/node/src/integrations/tracing/effect/types.ts

@@ -0,0 +1,35 @@
+// Type definitions based on Effect's actual API
+export interface EffectSpan {
+  name: string;
+  startTime: bigint;
+  endTime?: bigint;
+  attributes?: Record<string, unknown>;
+  status?: {
+    code: number;
+    message?: string;
+  };
+  parent?: EffectSpan;
+}
+
+export interface EffectExit<E = unknown, A = unknown> {
+  readonly _tag: 'Success' | 'Failure' | 'Interrupt';
+  readonly cause?: E;
+  readonly value?: A;
+}
+
+export interface EffectTracer {
+  onSpanStart?: (span: EffectSpan) => void;
+  onSpanEnd?: (span: EffectSpan, exit: EffectExit) => void;
+  span<A>(name: string, f: () => A): A;
+  withSpan<A>(span: EffectSpan, f: () => A): A;
+}
+
+export interface EffectModule {
+  Tracer?: {
+    get?: () => EffectTracer | undefined;
+    current?: () => EffectTracer | undefined;
+    set?: (tracer: EffectTracer) => void;
+    register?: (tracer: EffectTracer) => void;
+    use?: (tracer: EffectTracer) => void;
+  };
+}

packages/node/src/integrations/tracing/index.ts

@@ -3,6 +3,7 @@ import { instrumentOtelHttp, instrumentSentryHttp } from '../http';
 import { amqplibIntegration, instrumentAmqplib } from './amqplib';
 import { anthropicAIIntegration, instrumentAnthropicAi } from './anthropic-ai';
 import { connectIntegration, instrumentConnect } from './connect';
+import { effectIntegration, instrumentEffect } from './effect';
 import { expressIntegration, instrumentExpress } from './express';
 import { fastifyIntegration, instrumentFastify, instrumentFastifyV3 } from './fastify';
 import { firebaseIntegration, instrumentFirebase } from './firebase';
@@ -62,6 +63,7 @@ export function getAutoPerformanceIntegrations(): Integration[] {
     googleGenAIIntegration(),
     postgresJsIntegration(),
     firebaseIntegration(),
+    effectIntegration(),
   ];
 }
 
@@ -101,5 +103,6 @@ export function getOpenTelemetryInstrumentationToPreload(): (((options?: any) =>
     instrumentAnthropicAi,
     instrumentGoogleGenAI,
     instrumentLangGraph,
+    instrumentEffect,
   ];
 }