feat: Add tests for effect

JPeer264 · JPeer264 · commit 6735fa7483ff · 2026-03-02T20:44:49.000+01:00
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/.gitignore b/dev-packages/e2e-tests/test-applications/node-effect/.gitignore
@@ -0,0 +1,2 @@
+dist
+node_modules
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/.npmrc b/dev-packages/e2e-tests/test-applications/node-effect/.npmrc
@@ -0,0 +1,2 @@
+@sentry:registry=http://127.0.0.1:4873
+@sentry-internal:registry=http://127.0.0.1:4873
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/package.json b/dev-packages/e2e-tests/test-applications/node-effect/package.json
@@ -0,0 +1,30 @@
+{
+  "name": "node-effect-app",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node --import=./src/instrument.js dist/app.js",
+    "test": "playwright test",
+    "clean": "npx rimraf node_modules pnpm-lock.yaml",
+    "test:build": "pnpm install && pnpm build",
+    "test:assert": "pnpm test"
+  },
+  "dependencies": {
+    "@effect/platform": "^0.94.0",
+    "@effect/platform-node": "^0.104.0",
+    "@sentry/core": "latest || *",
+    "@sentry/node": "latest || *",
+    "@types/node": "^18.19.1",
+    "effect": "^3.0.0",
+    "typescript": "~5.0.0"
+  },
+  "devDependencies": {
+    "@playwright/test": "~1.56.0",
+    "@sentry-internal/test-utils": "link:../../../test-utils"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  }
+}
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/playwright.config.mjs b/dev-packages/e2e-tests/test-applications/node-effect/playwright.config.mjs
@@ -0,0 +1,7 @@
+import { getPlaywrightConfig } from '@sentry-internal/test-utils';
+
+const config = getPlaywrightConfig({
+  startCommand: `pnpm start`,
+});
+
+export default config;
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/src/Api.ts b/dev-packages/e2e-tests/test-applications/node-effect/src/Api.ts
@@ -0,0 +1,4 @@
+import { HttpApi } from '@effect/platform';
+import { TestApi } from './Test/Api.js';
+
+export class Api extends HttpApi.make('api').add(TestApi) {}
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/src/Http.ts b/dev-packages/e2e-tests/test-applications/node-effect/src/Http.ts
@@ -0,0 +1,14 @@
+import { HttpApiBuilder, HttpMiddleware, HttpServer } from '@effect/platform';
+import { NodeHttpServer } from '@effect/platform-node';
+import { Layer } from 'effect';
+import { createServer } from 'http';
+import { Api } from './Api.js';
+import { HttpTestLive } from './Test/Http.js';
+
+const ApiLive = Layer.provide(HttpApiBuilder.api(Api), [HttpTestLive]);
+
+export const HttpLive = HttpApiBuilder.serve(HttpMiddleware.logger).pipe(
+  Layer.provide(ApiLive),
+  HttpServer.withLogAddress,
+  Layer.provide(NodeHttpServer.layer(createServer, { port: 3030 })),
+);
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/src/Test/Api.ts b/dev-packages/e2e-tests/test-applications/node-effect/src/Test/Api.ts
@@ -0,0 +1,31 @@
+import { HttpApiEndpoint, HttpApiGroup } from '@effect/platform';
+import { Schema } from 'effect';
+
+export const TestResult = Schema.Struct({
+  status: Schema.String,
+});
+
+export const NestedResult = Schema.Struct({
+  result: Schema.String,
+});
+
+export const ErrorResult = Schema.Struct({
+  error: Schema.String,
+});
+
+export const LogResult = Schema.Struct({
+  logged: Schema.Boolean,
+});
+
+export const MetricResult = Schema.Struct({
+  incremented: Schema.Number,
+});
+
+export class TestApi extends HttpApiGroup.make('test')
+  .add(HttpApiEndpoint.get('success', '/test-success').addSuccess(TestResult))
+  .add(HttpApiEndpoint.get('effectSpan', '/test-effect-span').addSuccess(TestResult))
+  .add(HttpApiEndpoint.get('nestedSpans', '/test-nested-spans').addSuccess(NestedResult))
+  .add(HttpApiEndpoint.get('effectError', '/test-effect-error').addSuccess(ErrorResult))
+  .add(HttpApiEndpoint.get('effectLog', '/test-effect-log').addSuccess(LogResult))
+  .add(HttpApiEndpoint.get('effectMetric', '/test-effect-metric').addSuccess(MetricResult))
+  .add(HttpApiEndpoint.get('effectWithHttp', '/test-effect-with-http').addSuccess(TestResult)) {}
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/src/Test/Http.ts b/dev-packages/e2e-tests/test-applications/node-effect/src/Test/Http.ts
@@ -0,0 +1,72 @@
+import { HttpApiBuilder } from '@effect/platform';
+import { Effect, Metric } from 'effect';
+import { Api } from '../Api.js';
+
+const requestCounter = Metric.counter('http_requests_total').pipe(Metric.withConstantInput(1));
+
+export const HttpTestLive = HttpApiBuilder.group(Api, 'test', handlers =>
+  Effect.gen(function* () {
+    return handlers
+      .handle('success', () => Effect.succeed({ status: 'ok' }))
+
+      .handle('effectSpan', () =>
+        Effect.gen(function* () {
+          yield* Effect.log('Starting effect span test');
+          yield* Effect.sleep('10 millis');
+          return { status: 'ok' };
+        }).pipe(Effect.withSpan('test-effect-span')),
+      )
+
+      .handle('nestedSpans', () => {
+        const innerEffect = Effect.gen(function* () {
+          yield* Effect.sleep('5 millis');
+          return 'inner-result';
+        }).pipe(Effect.withSpan('inner-span'));
+
+        return Effect.gen(function* () {
+          const result = yield* innerEffect;
+          yield* Effect.sleep('5 millis');
+          return { result };
+        }).pipe(Effect.withSpan('outer-span'));
+      })
+
+      .handle('effectError', () =>
+        Effect.gen(function* () {
+          yield* Effect.fail(new Error('Effect error'));
+          return { error: '' };
+        }).pipe(
+          Effect.withSpan('error-span'),
+          Effect.catchAll(error =>
+            Effect.succeed({ error: error instanceof Error ? error.message : String(error) }),
+          ),
+        ),
+      )
+
+      .handle('effectLog', () =>
+        Effect.gen(function* () {
+          yield* Effect.log('Test info log message');
+          yield* Effect.logDebug('Test debug log message');
+          yield* Effect.logWarning('Test warning log message');
+          yield* Effect.logError('Test error log message');
+          return { logged: true };
+        }),
+      )
+
+      .handle('effectMetric', () =>
+        Effect.gen(function* () {
+          yield* Metric.increment(requestCounter);
+          yield* Metric.increment(requestCounter);
+          yield* Metric.increment(requestCounter);
+          return { incremented: 3 };
+        }),
+      )
+
+      .handle('effectWithHttp', () =>
+        Effect.gen(function* () {
+          yield* Effect.log('Processing request');
+          yield* Effect.sleep('10 millis');
+          return { status: 'ok' };
+        }).pipe(Effect.withSpan('process-request', { kind: 'server' })),
+      );
+  }),
+);
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/src/app.ts b/dev-packages/e2e-tests/test-applications/node-effect/src/app.ts
@@ -0,0 +1,8 @@
+import { NodeRuntime } from '@effect/platform-node';
+import { Layer } from 'effect';
+import { effectLayer } from '@sentry/core/effect';
+import { HttpLive } from './Http.js';
+
+const MainLive = HttpLive.pipe(Layer.provide(effectLayer));
+
+MainLive.pipe(Layer.launch, NodeRuntime.runMain);
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/src/instrument.js b/dev-packages/e2e-tests/test-applications/node-effect/src/instrument.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  environment: 'qa',
+  dsn: process.env.E2E_TEST_DSN,
+  debug: !!process.env.DEBUG,
+  tunnel: `http://localhost:3031/`,
+  tracesSampleRate: 1,
+  enableLogs: true,
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/start-event-proxy.mjs b/dev-packages/e2e-tests/test-applications/node-effect/start-event-proxy.mjs
@@ -0,0 +1,6 @@
+import { startEventProxyServer } from '@sentry-internal/test-utils';
+
+startEventProxyServer({
+  port: 3031,
+  proxyServerName: 'node-effect',
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/tests/logs.test.ts b/dev-packages/e2e-tests/test-applications/node-effect/tests/logs.test.ts
@@ -0,0 +1,60 @@
+import { expect, test } from '@playwright/test';
+import { waitForEnvelopeItem } from '@sentry-internal/test-utils';
+import type { SerializedLog, SerializedLogContainer } from '@sentry/core';
+
+async function collectLogItems(baseURL: string, endpoint: string): Promise<SerializedLog[]> {
+  const items: SerializedLog[] = [];
+
+  const logEnvelopePromise = waitForEnvelopeItem('node-effect', envelope => {
+    if (envelope[0].type !== 'log') return false;
+    const container = envelope[1] as SerializedLogContainer;
+    items.push(...container.items);
+    return container.items.some(item => item.body?.toString().includes('Test'));
+  });
+
+  await fetch(`${baseURL}${endpoint}`);
+  await logEnvelopePromise;
+
+  return items;
+}
+
+test('Captures Effect logs with correct severity levels', async ({ baseURL }) => {
+  const items = await collectLogItems(baseURL!, '/test-effect-log');
+
+  expect(items.length).toBeGreaterThan(0);
+
+  const infoLog = items.find(item => item.body?.toString().includes('Test info log message'));
+  expect(infoLog).toBeDefined();
+  expect(infoLog?.severity_number).toBe(9);
+
+  const warningLog = items.find(item => item.body?.toString().includes('Test warning log message'));
+  expect(warningLog).toBeDefined();
+  expect(warningLog?.severity_number).toBe(13);
+
+  const errorLog = items.find(item => item.body?.toString().includes('Test error log message'));
+  expect(errorLog).toBeDefined();
+  expect(errorLog?.severity_number).toBe(17);
+
+  for (const item of items) {
+    expect(item.body).toBeDefined();
+    expect(item.severity_number).toBeDefined();
+    expect(item.timestamp).toBeDefined();
+  }
+});
+
+test('Effect logs are associated with trace context when inside a span', async ({ baseURL }) => {
+  const logEnvelopePromise = waitForEnvelopeItem('node-effect', envelope => {
+    if (envelope[0].type !== 'log') return false;
+    const container = envelope[1] as SerializedLogContainer;
+    return container.items.some(item => item.body?.toString().includes('Starting effect span test'));
+  });
+
+  await fetch(`${baseURL}/test-effect-span`);
+
+  const logEnvelope = await logEnvelopePromise;
+  const container = logEnvelope[1] as SerializedLogContainer;
+  const spanLog = container.items.find(item => item.body?.toString().includes('Starting effect span test'));
+
+  expect(spanLog).toBeDefined();
+  expect(spanLog?.trace_id).toBeDefined();
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/tests/tracing.test.ts b/dev-packages/e2e-tests/test-applications/node-effect/tests/tracing.test.ts
@@ -0,0 +1,111 @@
+import { expect, test } from '@playwright/test';
+import { waitForTransaction } from '@sentry-internal/test-utils';
+
+test('Sends an Effect span as a Sentry transaction', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('node-effect', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent?.transaction === 'GET /test-effect-span'
+    );
+  });
+
+  await fetch(`${baseURL}/test-effect-span`);
+
+  const transactionEvent = await transactionEventPromise;
+
+  expect(transactionEvent.contexts?.trace?.op).toEqual('http.server');
+  expect(transactionEvent.transaction).toEqual('GET /test-effect-span');
+
+  const spans = transactionEvent.spans || [];
+
+  expect(spans).toContainEqual(
+    expect.objectContaining({
+      description: 'test-effect-span',
+      op: 'internal',
+      origin: 'manual',
+      status: 'ok',
+    }),
+  );
+});
+
+test('Captures nested Effect spans correctly', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('node-effect', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent?.transaction === 'GET /test-nested-spans'
+    );
+  });
+
+  await fetch(`${baseURL}/test-nested-spans`);
+
+  const transactionEvent = await transactionEventPromise;
+
+  expect(transactionEvent.contexts?.trace?.op).toEqual('http.server');
+  expect(transactionEvent.transaction).toEqual('GET /test-nested-spans');
+
+  const spans = transactionEvent.spans || [];
+
+  const outerSpan = spans.find(span => span.description === 'outer-span');
+  const innerSpan = spans.find(span => span.description === 'inner-span');
+
+  expect(outerSpan).toBeDefined();
+  expect(innerSpan).toBeDefined();
+
+  expect(outerSpan).toMatchObject({
+    description: 'outer-span',
+    op: 'internal',
+    status: 'ok',
+  });
+
+  expect(innerSpan).toMatchObject({
+    description: 'inner-span',
+    op: 'internal',
+    status: 'ok',
+  });
+
+  expect(innerSpan?.parent_span_id).toEqual(outerSpan?.span_id);
+});
+
+test('Captures Effect span error status correctly', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('node-effect', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent?.transaction === 'GET /test-effect-error'
+    );
+  });
+
+  await fetch(`${baseURL}/test-effect-error`);
+
+  const transactionEvent = await transactionEventPromise;
+
+  const spans = transactionEvent.spans || [];
+
+  const errorSpan = spans.find(span => span.description === 'error-span');
+
+  expect(errorSpan).toBeDefined();
+  expect(errorSpan).toMatchObject({
+    description: 'error-span',
+    op: 'internal',
+    status: 'internal_error',
+  });
+});
+
+test('Effect server spans attach to existing HTTP server span', async ({ baseURL }) => {
+  const transactionEventPromise = waitForTransaction('node-effect', transactionEvent => {
+    return (
+      transactionEvent?.contexts?.trace?.op === 'http.server' &&
+      transactionEvent?.transaction === 'GET /test-effect-with-http'
+    );
+  });
+
+  await fetch(`${baseURL}/test-effect-with-http`);
+
+  const transactionEvent = await transactionEventPromise;
+
+  expect(transactionEvent.contexts?.trace?.op).toEqual('http.server');
+
+  const spans = transactionEvent.spans || [];
+
+  const processSpan = spans.find(span => span.description === 'process-request');
+  expect(processSpan).toBeUndefined();
+});
diff --git a/dev-packages/e2e-tests/test-applications/node-effect/tsconfig.json b/dev-packages/e2e-tests/test-applications/node-effect/tsconfig.json
@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "types": ["node"],
+    "esModuleInterop": true,
+    "lib": ["es2020"],
+    "strict": true,
+    "outDir": "dist",
+    "skipLibCheck": true,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext"
+  },
+  "include": ["src/**/*.ts"]
+}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+@sentry:registry=http://127.0.0.1:4873`
	`2`	`+@sentry-internal:registry=http://127.0.0.1:4873`