Add Effect/OpenTelemetry tracing with Sentry integration

- Upgrade @sentry/node to v8 with skipOpenTelemetrySetup
- Add @effect/opentelemetry and OpenTelemetry SDK packages
- Add @sentry/opentelemetry for span export
- Add posthog-node for future server-side analytics
- Create tracing.ts with SentrySpanProcessor, SentrySampler, SentryPropagator
- Update runtime.ts to provide TracingLive layer to all effects

Effects using Effect.withSpan will now have their spans exported to Sentry
for visualization in the Performance dashboard.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: vcarl

app/effects/runtime.ts

@@ -1,27 +1,35 @@
 import { Effect } from "effect";
 
+import { TracingLive } from "./tracing.js";
+
 /**
- * Minimal runtime helpers for running Effects in the Promise-based codebase.
+ * Runtime helpers for running Effects in the Promise-based codebase.
  * These provide the bridge between Effect-based code and legacy async/await code.
+ *
+ * The tracing layer is automatically provided to all effects run through these
+ * helpers, so spans created with Effect.withSpan will be exported to Sentry.
  */
 
 /**
  * Run an Effect and return a Promise that resolves with the success value.
+ * Automatically provides the tracing layer for Sentry integration.
  * Throws if the Effect fails.
  */
 export const runEffect = <A, E>(
   effect: Effect.Effect<A, E, never>,
-): Promise<A> => Effect.runPromise(effect);
+): Promise<A> => Effect.runPromise(effect.pipe(Effect.provide(TracingLive)));
 
 /**
  * Run an Effect and return a Promise that resolves with an Exit value.
+ * Automatically provides the tracing layer for Sentry integration.
  * Never throws - use this when you need to inspect failures.
  */
 export const runEffectExit = <A, E>(effect: Effect.Effect<A, E, never>) =>
-  Effect.runPromiseExit(effect);
+  Effect.runPromiseExit(effect.pipe(Effect.provide(TracingLive)));
 
 /**
  * Run an Effect synchronously.
+ * Note: Tracing is not provided for sync execution - use runEffect for traced effects.
  * Only use for Effects that are guaranteed to be synchronous.
  */
 export const runEffectSync = <A, E>(effect: Effect.Effect<A, E, never>): A =>

app/effects/tracing.ts

@@ -0,0 +1,29 @@
+import { NodeSdk } from "@effect/opentelemetry";
+import {
+  SentryPropagator,
+  SentrySampler,
+  SentrySpanProcessor,
+} from "@sentry/opentelemetry";
+
+import Sentry, { isValidDsn } from "#~/helpers/sentry.server.js";
+
+/**
+ * Effect OpenTelemetry layer that exports spans to Sentry.
+ *
+ * This layer integrates Effect's native tracing (Effect.withSpan) with Sentry.
+ * All spans created with Effect.withSpan will be exported to Sentry for
+ * visualization in their Performance dashboard.
+ *
+ * The layer uses:
+ * - SentrySpanProcessor: Exports spans to Sentry (it IS a SpanProcessor, not an exporter)
+ * - SentrySampler: Respects Sentry's tracesSampleRate
+ * - SentryPropagator: Enables distributed tracing
+ */
+export const TracingLive = NodeSdk.layer(() => ({
+  resource: { serviceName: "mod-bot" },
+  // Only add Sentry processors if Sentry is configured
+  // SentrySpanProcessor is already a SpanProcessor, don't wrap in BatchSpanProcessor
+  spanProcessor: isValidDsn ? new SentrySpanProcessor() : undefined,
+  sampler: isValidDsn ? new SentrySampler(Sentry.getClient()!) : undefined,
+  propagator: isValidDsn ? new SentryPropagator() : undefined,
+}));

app/helpers/sentry.server.ts

@@ -3,20 +3,17 @@ import * as Sentry from "@sentry/node";
 import { isProd, sentryIngest } from "#~/helpers/env.server";
 
 // Only initialize Sentry if DSN is valid (not a placeholder like "example.com")
-const isValidDsn = sentryIngest.startsWith("https://");
+export const isValidDsn = sentryIngest.startsWith("https://");
 
 if (isValidDsn) {
-  const sentryOptions = {
+  const sentryOptions: Sentry.NodeOptions = {
     dsn: sentryIngest,
     environment: isProd() ? "production" : "development",
-    integrations: [
-      new Sentry.Integrations.OnUncaughtException(),
-      new Sentry.Integrations.OnUnhandledRejection(),
-    ],
-
+    // Skip Sentry's auto OpenTelemetry setup - we'll use Effect's OpenTelemetry
+    // and provide the SentrySpanProcessor to it
+    skipOpenTelemetrySetup: true,
     // Set tracesSampleRate to 1.0 to capture 100%
     // of transactions for performance monitoring.
-    // We recommend adjusting this value in production
     tracesSampleRate: isProd() ? 0.2 : 1,
     sendDefaultPii: true,
   };