From be7f55bb984b98225993368f3def7070e783ab4e Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Mon, 24 Mar 2025 16:17:38 -0400
Subject: [PATCH 01/11] test: Add browser integration tests for logs

---
 .../suites/public-api/logger/init.js          | 10 +++++
 .../suites/public-api/logger/subject.js       |  6 +++
 .../suites/public-api/logger/test.ts          | 38 +++++++++++++++++++
 3 files changed, 54 insertions(+)
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/logger/init.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
 create mode 100644 dev-packages/browser-integration-tests/suites/public-api/logger/test.ts

diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/init.js b/dev-packages/browser-integration-tests/suites/public-api/logger/init.js
new file mode 100644
index 000000000000..27397e0f90ce
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/init.js
@@ -0,0 +1,10 @@
+import * as Sentry from '@sentry/browser';
+
+window.Sentry = Sentry;
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  _experiments: {
+    enableLogs: true,
+  },
+});
diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js b/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
new file mode 100644
index 000000000000..1cb34d65f0ae
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
@@ -0,0 +1,6 @@
+Sentry.logger.info('test info');
+Sentry.logger.debug('test debug');
+Sentry.logger.warn('test warn');
+Sentry.logger.error('test error');
+Sentry.logger.fatal('test fatal');
+Sentry.logger.critical('test critical');
diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
new file mode 100644
index 000000000000..2f671bc87afe
--- /dev/null
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
@@ -0,0 +1,38 @@
+import { expect } from '@playwright/test';
+import type { SerializedOtelLog } from '@sentry/core';
+
+import { sentryTest } from '../../../utils/fixtures';
+import { getFirstSentryEnvelopeRequest } from '../../../utils/helpers';
+
+sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page }) => {
+  const url = await getLocalTestUrl({ testDir: __dirname });
+
+  // Get all events from the page
+  const events = await Promise.all([
+    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
+    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
+    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
+    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
+    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
+    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
+  ]);
+
+  // Verify each log level
+  expect(events[0].severityText).toBe('info');
+  expect(events[0].body.stringValue).toBe('test info');
+
+  expect(events[1].severityText).toBe('debug');
+  expect(events[1].body.stringValue).toBe('test debug');
+
+  expect(events[2].severityText).toBe('warning');
+  expect(events[2].body.stringValue).toBe('test warn');
+
+  expect(events[3].severityText).toBe('error');
+  expect(events[3].body.stringValue).toBe('test error');
+
+  expect(events[4].severityText).toBe('fatal');
+  expect(events[4].body.stringValue).toBe('test fatal');
+
+  expect(events[5].severityText).toBe('critical');
+  expect(events[5].body.stringValue).toBe('test critical');
+});

From 9376f7fb625d697756ff26ceaceafc3517943f54 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 11:23:51 -0400
Subject: [PATCH 02/11] more changes

---
 .../suites/public-api/logger/subject.js       |  17 +-
 .../suites/public-api/logger/test.ts          | 154 +++++++++++++++---
 .../utils/helpers.ts                          |  12 +-
 packages/core/src/logs/constants.ts           |   1 +
 packages/core/src/types-hoist/index.ts        |   2 +
 5 files changed, 159 insertions(+), 27 deletions(-)

diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js b/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
index 1cb34d65f0ae..e19eda76e15e 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
@@ -1,6 +1,21 @@
-Sentry.logger.info('test info');
+Sentry.logger.trace('test trace');
 Sentry.logger.debug('test debug');
+Sentry.logger.info('test info');
 Sentry.logger.warn('test warn');
 Sentry.logger.error('test error');
 Sentry.logger.fatal('test fatal');
 Sentry.logger.critical('test critical');
+
+const formattedMessage = (message, ...args) => {
+  return Sentry.logger.fmt`test ${message} ${args}`;
+};
+
+Sentry.logger.trace(formattedMessage('trace', 'stringArg', 123));
+Sentry.logger.debug(formattedMessage('debug', 'stringArg', 123));
+Sentry.logger.info(formattedMessage('info', 'stringArg', 123));
+Sentry.logger.warn(formattedMessage('warn', 'stringArg', 123));
+Sentry.logger.error(formattedMessage('error', 'stringArg', 123));
+Sentry.logger.fatal(formattedMessage('fatal', 'stringArg', 123));
+Sentry.logger.critical(formattedMessage('critical', 'stringArg', 123));
+
+Sentry.flush();
diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
index 2f671bc87afe..b058605903cf 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
@@ -1,38 +1,148 @@
 import { expect } from '@playwright/test';
-import type { SerializedOtelLog } from '@sentry/core';
+import type { OtelLogEnvelope } from '@sentry/core';
 
 import { sentryTest } from '../../../utils/fixtures';
-import { getFirstSentryEnvelopeRequest } from '../../../utils/helpers';
+import { getFirstSentryEnvelopeRequest, properFullEnvelopeRequestParser } from '../../../utils/helpers';
 
 sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page }) => {
   const url = await getLocalTestUrl({ testDir: __dirname });
 
   // Get all events from the page
-  const events = await Promise.all([
-    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
-    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
-    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
-    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
-    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
-    getFirstSentryEnvelopeRequest<SerializedOtelLog>(page, url),
+  const event = await getFirstSentryEnvelopeRequest<OtelLogEnvelope>(page, url, properFullEnvelopeRequestParser);
+  const [envelopeHeader, envelopeItems] = event;
+
+  expect(envelopeHeader).toEqual({ sdk: { name: 'sentry.javascript.browser', version: expect.any(String) } });
+
+  expect(envelopeItems.length).toBe(14);
+
+  expect(envelopeItems[0]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'trace',
+      body: { stringValue: 'test trace' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
   ]);
 
-  // Verify each log level
-  expect(events[0].severityText).toBe('info');
-  expect(events[0].body.stringValue).toBe('test info');
+  expect(envelopeItems[1]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'debug',
+      body: { stringValue: 'test debug' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 5,
+    },
+  ]);
 
-  expect(events[1].severityText).toBe('debug');
-  expect(events[1].body.stringValue).toBe('test debug');
+  expect(envelopeItems[2]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'info',
+      body: { stringValue: 'test info' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
 
-  expect(events[2].severityText).toBe('warning');
-  expect(events[2].body.stringValue).toBe('test warn');
+  expect(envelopeItems[3]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'warn',
+      body: { stringValue: 'test warn' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
 
-  expect(events[3].severityText).toBe('error');
-  expect(events[3].body.stringValue).toBe('test error');
+  expect(envelopeItems[4]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'error',
+      body: { stringValue: 'test error' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
 
-  expect(events[4].severityText).toBe('fatal');
-  expect(events[4].body.stringValue).toBe('test fatal');
+  expect(envelopeItems[5]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'fatal',
+      body: { stringValue: 'test fatal' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
 
-  expect(events[5].severityText).toBe('critical');
-  expect(events[5].body.stringValue).toBe('test critical');
+  expect(envelopeItems[6]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'critical',
+      body: { stringValue: 'test critical' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
+
+  expect(envelopeItems[7]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'trace',
+      body: { stringValue: 'test trace stringArg 123' },
+      attributes: [
+        {
+          key: 'sentry.message.template',
+          value: {
+            stringValue: 'test %s %s',
+          },
+        },
+        {
+          key: 'sentry.message.params.0',
+          value: {
+            stringValue: 'stringArg',
+          },
+        },
+        {
+          key: 'sentry.message.params.1',
+          value: {
+            doubleValue: 123,
+          },
+        },
+      ],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
 });
diff --git a/dev-packages/browser-integration-tests/utils/helpers.ts b/dev-packages/browser-integration-tests/utils/helpers.ts
index 0d2b17cc0db9..0e17852a5b86 100644
--- a/dev-packages/browser-integration-tests/utils/helpers.ts
+++ b/dev-packages/browser-integration-tests/utils/helpers.ts
@@ -16,6 +16,7 @@ export const envelopeUrlRegex = /\.sentry\.io\/api\/\d+\/envelope\//;
 export const envelopeParser = (request: Request | null): unknown[] => {
   // https://develop.sentry.dev/sdk/envelopes/
   const envelope = request?.postData() || '';
+  console.log(envelope);
 
   // Third row of the envelop is the event payload.
   return envelope.split('\n').map(line => {
@@ -135,10 +136,13 @@ export const countEnvelopes = async (
 
     page.on('request', requestHandler);
 
-    setTimeout(() => {
-      page.off('request', requestHandler);
-      resolve(reqCount);
-    }, options?.timeout || 1000);
+    setTimeout(
+      () => {
+        page.off('request', requestHandler);
+        resolve(reqCount);
+      },
+      options?.timeout || 1000,
+    );
   });
 
   if (options?.url) {
diff --git a/packages/core/src/logs/constants.ts b/packages/core/src/logs/constants.ts
index d23a99ac95c7..c40dfe05c024 100644
--- a/packages/core/src/logs/constants.ts
+++ b/packages/core/src/logs/constants.ts
@@ -12,4 +12,5 @@ export const SEVERITY_TEXT_TO_SEVERITY_NUMBER: Partial<Record<LogSeverityLevel,
   warn: 13,
   error: 17,
   fatal: 21,
+  critical: 25,
 };
diff --git a/packages/core/src/types-hoist/index.ts b/packages/core/src/types-hoist/index.ts
index 1ca827f225a5..1659aeda9bc0 100644
--- a/packages/core/src/types-hoist/index.ts
+++ b/packages/core/src/types-hoist/index.ts
@@ -49,6 +49,8 @@ export type {
   ProfileChunkItem,
   SpanEnvelope,
   SpanItem,
+  OtelLogEnvelope,
+  OtelLogItem,
 } from './envelope';
 export type { ExtendedError } from './error';
 export type { Event, EventHint, EventType, ErrorEvent, TransactionEvent } from './event';

From 58aaf24da3d3cc20c5801033ff26227865377c75 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 12:54:55 -0400
Subject: [PATCH 03/11] fix all tests

---
 .../suites/public-api/logger/subject.js       |  18 +-
 .../suites/public-api/logger/test.ts          | 251 +++++++++++++++++-
 2 files changed, 245 insertions(+), 24 deletions(-)

diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js b/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
index e19eda76e15e..e175ee4c9e27 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/subject.js
@@ -4,18 +4,16 @@ Sentry.logger.info('test info');
 Sentry.logger.warn('test warn');
 Sentry.logger.error('test error');
 Sentry.logger.fatal('test fatal');
-Sentry.logger.critical('test critical');
 
-const formattedMessage = (message, ...args) => {
-  return Sentry.logger.fmt`test ${message} ${args}`;
+const formattedMessage = (message, stringArg, boolArg, numberArg) => {
+  return Sentry.logger.fmt`test ${message} ${stringArg} ${boolArg} ${numberArg}`;
 };
 
-Sentry.logger.trace(formattedMessage('trace', 'stringArg', 123));
-Sentry.logger.debug(formattedMessage('debug', 'stringArg', 123));
-Sentry.logger.info(formattedMessage('info', 'stringArg', 123));
-Sentry.logger.warn(formattedMessage('warn', 'stringArg', 123));
-Sentry.logger.error(formattedMessage('error', 'stringArg', 123));
-Sentry.logger.fatal(formattedMessage('fatal', 'stringArg', 123));
-Sentry.logger.critical(formattedMessage('critical', 'stringArg', 123));
+Sentry.logger.trace(formattedMessage('trace', 'stringArg', false, 123));
+Sentry.logger.debug(formattedMessage('debug', 'stringArg', false, 123));
+Sentry.logger.info(formattedMessage('info', 'stringArg', false, 123));
+Sentry.logger.warn(formattedMessage('warn', 'stringArg', false, 123));
+Sentry.logger.error(formattedMessage('error', 'stringArg', false, 123));
+Sentry.logger.fatal(formattedMessage('fatal', 'stringArg', false, 123));
 
 Sentry.flush();
diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
index b058605903cf..a60c0f57642a 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
@@ -13,7 +13,7 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
 
   expect(envelopeHeader).toEqual({ sdk: { name: 'sentry.javascript.browser', version: expect.any(String) } });
 
-  expect(envelopeItems.length).toBe(14);
+  expect(envelopeItems.length).toBe(12);
 
   expect(envelopeItems[0]).toEqual([
     {
@@ -53,7 +53,7 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       attributes: [],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
-      severityNumber: 1,
+      severityNumber: 9,
     },
   ]);
 
@@ -67,7 +67,7 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       attributes: [],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
-      severityNumber: 1,
+      severityNumber: 13,
     },
   ]);
 
@@ -81,7 +81,7 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       attributes: [],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
-      severityNumber: 1,
+      severityNumber: 17,
     },
   ]);
 
@@ -95,7 +95,7 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       attributes: [],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
-      severityNumber: 1,
+      severityNumber: 21,
     },
   ]);
 
@@ -104,9 +104,40 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       type: 'otel_log',
     },
     {
-      severityText: 'critical',
-      body: { stringValue: 'test critical' },
-      attributes: [],
+      severityText: 'trace',
+      body: { stringValue: 'test trace stringArg false 123' },
+      attributes: [
+        {
+          key: 'sentry.message.template',
+          value: {
+            stringValue: 'test %s %s %s %s',
+          },
+        },
+        {
+          key: 'sentry.message.param.0',
+          value: {
+            stringValue: 'trace',
+          },
+        },
+        {
+          key: 'sentry.message.param.1',
+          value: {
+            stringValue: 'stringArg',
+          },
+        },
+        {
+          key: 'sentry.message.param.2',
+          value: {
+            boolValue: false,
+          },
+        },
+        {
+          key: 'sentry.message.param.3',
+          value: {
+            doubleValue: 123,
+          },
+        },
+      ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
       severityNumber: 1,
@@ -118,23 +149,35 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       type: 'otel_log',
     },
     {
-      severityText: 'trace',
-      body: { stringValue: 'test trace stringArg 123' },
+      severityText: 'debug',
+      body: { stringValue: 'test debug stringArg false 123' },
       attributes: [
         {
           key: 'sentry.message.template',
           value: {
-            stringValue: 'test %s %s',
+            stringValue: 'test %s %s %s %s',
           },
         },
         {
-          key: 'sentry.message.params.0',
+          key: 'sentry.message.param.0',
+          value: {
+            stringValue: 'debug',
+          },
+        },
+        {
+          key: 'sentry.message.param.1',
           value: {
             stringValue: 'stringArg',
           },
         },
         {
-          key: 'sentry.message.params.1',
+          key: 'sentry.message.param.2',
+          value: {
+            boolValue: false,
+          },
+        },
+        {
+          key: 'sentry.message.param.3',
           value: {
             doubleValue: 123,
           },
@@ -142,7 +185,187 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
       ],
       timeUnixNano: expect.any(String),
       traceId: expect.any(String),
-      severityNumber: 1,
+      severityNumber: 5,
+    },
+  ]);
+
+  expect(envelopeItems[8]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'info',
+      body: { stringValue: 'test info stringArg false 123' },
+      attributes: [
+        {
+          key: 'sentry.message.template',
+          value: {
+            stringValue: 'test %s %s %s %s',
+          },
+        },
+        {
+          key: 'sentry.message.param.0',
+          value: {
+            stringValue: 'info',
+          },
+        },
+        {
+          key: 'sentry.message.param.1',
+          value: {
+            stringValue: 'stringArg',
+          },
+        },
+        {
+          key: 'sentry.message.param.2',
+          value: {
+            boolValue: false,
+          },
+        },
+        {
+          key: 'sentry.message.param.3',
+          value: {
+            doubleValue: 123,
+          },
+        },
+      ],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 9,
+    },
+  ]);
+
+  expect(envelopeItems[9]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'warn',
+      body: { stringValue: 'test warn stringArg false 123' },
+      attributes: [
+        {
+          key: 'sentry.message.template',
+          value: {
+            stringValue: 'test %s %s %s %s',
+          },
+        },
+        {
+          key: 'sentry.message.param.0',
+          value: {
+            stringValue: 'warn',
+          },
+        },
+        {
+          key: 'sentry.message.param.1',
+          value: {
+            stringValue: 'stringArg',
+          },
+        },
+        {
+          key: 'sentry.message.param.2',
+          value: {
+            boolValue: false,
+          },
+        },
+        {
+          key: 'sentry.message.param.3',
+          value: {
+            doubleValue: 123,
+          },
+        },
+      ],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 13,
+    },
+  ]);
+
+  expect(envelopeItems[10]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'error',
+      body: { stringValue: 'test error stringArg false 123' },
+      attributes: [
+        {
+          key: 'sentry.message.template',
+          value: {
+            stringValue: 'test %s %s %s %s',
+          },
+        },
+        {
+          key: 'sentry.message.param.0',
+          value: {
+            stringValue: 'error',
+          },
+        },
+        {
+          key: 'sentry.message.param.1',
+          value: {
+            stringValue: 'stringArg',
+          },
+        },
+        {
+          key: 'sentry.message.param.2',
+          value: {
+            boolValue: false,
+          },
+        },
+        {
+          key: 'sentry.message.param.3',
+          value: {
+            doubleValue: 123,
+          },
+        },
+      ],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 17,
+    },
+  ]);
+
+  expect(envelopeItems[11]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'fatal',
+      body: { stringValue: 'test fatal stringArg false 123' },
+      attributes: [
+        {
+          key: 'sentry.message.template',
+          value: {
+            stringValue: 'test %s %s %s %s',
+          },
+        },
+        {
+          key: 'sentry.message.param.0',
+          value: {
+            stringValue: 'fatal',
+          },
+        },
+        {
+          key: 'sentry.message.param.1',
+          value: {
+            stringValue: 'stringArg',
+          },
+        },
+        {
+          key: 'sentry.message.param.2',
+          value: {
+            boolValue: false,
+          },
+        },
+        {
+          key: 'sentry.message.param.3',
+          value: {
+            doubleValue: 123,
+          },
+        },
+      ],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 21,
     },
   ]);
 });

From 807d4cfa659a8c5867077f056ebc928161a45b23 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 14:07:20 -0400
Subject: [PATCH 04/11] remove console logging

---
 dev-packages/browser-integration-tests/utils/helpers.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dev-packages/browser-integration-tests/utils/helpers.ts b/dev-packages/browser-integration-tests/utils/helpers.ts
index 0e17852a5b86..d08ffccd7831 100644
--- a/dev-packages/browser-integration-tests/utils/helpers.ts
+++ b/dev-packages/browser-integration-tests/utils/helpers.ts
@@ -16,7 +16,6 @@ export const envelopeUrlRegex = /\.sentry\.io\/api\/\d+\/envelope\//;
 export const envelopeParser = (request: Request | null): unknown[] => {
   // https://develop.sentry.dev/sdk/envelopes/
   const envelope = request?.postData() || '';
-  console.log(envelope);
 
   // Third row of the envelop is the event payload.
   return envelope.split('\n').map(line => {

From c3605c4662d38113968d5930783c04477fb472b6 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 14:50:50 -0400
Subject: [PATCH 05/11] fix test assertion

---
 .../suites/public-api/logger/test.ts                          | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
index a60c0f57642a..31ef28c87057 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
@@ -9,9 +9,7 @@ sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page
 
   // Get all events from the page
   const event = await getFirstSentryEnvelopeRequest<OtelLogEnvelope>(page, url, properFullEnvelopeRequestParser);
-  const [envelopeHeader, envelopeItems] = event;
-
-  expect(envelopeHeader).toEqual({ sdk: { name: 'sentry.javascript.browser', version: expect.any(String) } });
+  const envelopeItems = event[1];
 
   expect(envelopeItems.length).toBe(12);
 

From 89c5c2ed88805aeeef5ea3f8c1f26a784882a0cb Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 17:16:08 -0400
Subject: [PATCH 06/11] remove this

---
 packages/core/src/logs/constants.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/core/src/logs/constants.ts b/packages/core/src/logs/constants.ts
index c40dfe05c024..d23a99ac95c7 100644
--- a/packages/core/src/logs/constants.ts
+++ b/packages/core/src/logs/constants.ts
@@ -12,5 +12,4 @@ export const SEVERITY_TEXT_TO_SEVERITY_NUMBER: Partial<Record<LogSeverityLevel,
   warn: 13,
   error: 17,
   fatal: 21,
-  critical: 25,
 };

From e69c2d994f76da0309b86a2c7294a904a7b8d29d Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 17:46:51 -0400
Subject: [PATCH 07/11] add node integration tests

---
 .../suites/public-api/logger/scenario.ts      |  48 +++
 .../suites/public-api/logger/test.ts          | 288 ++++++++++++++++++
 .../utils/assertions.ts                       |   7 +
 .../node-integration-tests/utils/runner.ts    |  20 +-
 4 files changed, 362 insertions(+), 1 deletion(-)
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts
 create mode 100644 dev-packages/node-integration-tests/suites/public-api/logger/test.ts

diff --git a/dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts
new file mode 100644
index 000000000000..a9b686c953ff
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts
@@ -0,0 +1,48 @@
+import { loggingTransport } from '@sentry-internal/node-integration-tests';
+import * as Sentry from '@sentry/node';
+
+Sentry.init({
+  dsn: 'https://public@dsn.ingest.sentry.io/1337',
+  release: '1.0',
+  environment: 'test',
+  _experiments: {
+    enableLogs: true,
+  },
+  transport: loggingTransport,
+});
+
+async function run(): Promise<void> {
+  Sentry.logger.trace('test trace');
+  Sentry.logger.debug('test debug');
+  Sentry.logger.info('test info');
+  Sentry.logger.warn('test warn');
+  Sentry.logger.error('test error');
+  Sentry.logger.fatal('test fatal');
+
+  const formattedMessage = (
+    message: string,
+    stringArg: string,
+    boolArg: boolean,
+    numberArg: number,
+  ): ReturnType<typeof Sentry.logger.fmt> => {
+    return Sentry.logger.fmt`test ${message} ${stringArg} ${boolArg} ${numberArg}`;
+  };
+
+  Sentry.logger.trace(formattedMessage('trace', 'stringArg', false, 123));
+  Sentry.logger.debug(formattedMessage('debug', 'stringArg', false, 123));
+  Sentry.logger.info(formattedMessage('info', 'stringArg', false, 123));
+  Sentry.logger.warn(formattedMessage('warn', 'stringArg', false, 123));
+  Sentry.logger.error(formattedMessage('error', 'stringArg', false, 123));
+  Sentry.logger.fatal(formattedMessage('fatal', 'stringArg', false, 123));
+
+  Sentry.logger.trace('test %s with node format', ['trace']);
+  Sentry.logger.debug('test %s with node format', ['debug']);
+  Sentry.logger.info('test %s with node format', ['info']);
+  Sentry.logger.warn('test %s with node format', ['warn']);
+  Sentry.logger.error('test %s with node format', ['error']);
+  Sentry.logger.fatal('test %s with node format', ['fatal']);
+
+  await Sentry.flush();
+}
+
+run().catch(() => undefined);
diff --git a/dev-packages/node-integration-tests/suites/public-api/logger/test.ts b/dev-packages/node-integration-tests/suites/public-api/logger/test.ts
new file mode 100644
index 000000000000..cb209c8d32ba
--- /dev/null
+++ b/dev-packages/node-integration-tests/suites/public-api/logger/test.ts
@@ -0,0 +1,288 @@
+import { afterAll, expect, test } from 'vitest';
+import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
+
+afterAll(() => {
+  cleanupChildProcesses();
+});
+
+test('should log messages with different levels and formats', async () => {
+  await createRunner(__dirname, 'scenario.ts')
+    .expect({
+      otel_log: {
+        severityText: 'trace',
+        severityNumber: 1, // TRACE
+        body: {
+          stringValue: 'test trace',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'debug',
+        severityNumber: 5, // DEBUG
+        body: {
+          stringValue: 'test debug',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'info',
+        severityNumber: 9, // INFO
+        body: {
+          stringValue: 'test info',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'warn',
+        severityNumber: 13, // WARN
+        body: {
+          stringValue: 'test warn',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'error',
+        severityNumber: 17, // ERROR
+        body: {
+          stringValue: 'test error',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'fatal',
+        severityNumber: 21, // FATAL
+        body: {
+          stringValue: 'test fatal',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'trace',
+        severityNumber: 1, // TRACE
+        body: {
+          stringValue: 'test trace stringArg false 123',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'trace' } },
+          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
+          { key: 'sentry.message.param.2', value: { boolValue: false } },
+          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'debug',
+        severityNumber: 5, // DEBUG
+        body: {
+          stringValue: 'test debug stringArg false 123',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'debug' } },
+          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
+          { key: 'sentry.message.param.2', value: { boolValue: false } },
+          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'info',
+        severityNumber: 9, // INFO
+        body: {
+          stringValue: 'test info stringArg false 123',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'info' } },
+          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
+          { key: 'sentry.message.param.2', value: { boolValue: false } },
+          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'warn',
+        severityNumber: 13, // WARN
+        body: {
+          stringValue: 'test warn stringArg false 123',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'warn' } },
+          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
+          { key: 'sentry.message.param.2', value: { boolValue: false } },
+          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'error',
+        severityNumber: 17, // ERROR
+        body: {
+          stringValue: 'test error stringArg false 123',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'error' } },
+          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
+          { key: 'sentry.message.param.2', value: { boolValue: false } },
+          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'fatal',
+        severityNumber: 21, // FATAL
+        body: {
+          stringValue: 'test fatal stringArg false 123',
+        },
+        attributes: [
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'fatal' } },
+          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
+          { key: 'sentry.message.param.2', value: { boolValue: false } },
+          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'trace',
+        severityNumber: 1, // TRACE
+        body: {
+          stringValue: 'test trace with node format',
+        },
+        attributes: [
+          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'trace' } },
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'debug',
+        severityNumber: 5, // DEBUG
+        body: {
+          stringValue: 'test debug with node format',
+        },
+        attributes: [
+          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'debug' } },
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'info',
+        severityNumber: 9, // INFO
+        body: {
+          stringValue: 'test info with node format',
+        },
+        attributes: [
+          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'info' } },
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'warn',
+        severityNumber: 13, // WARN
+        body: {
+          stringValue: 'test warn with node format',
+        },
+        attributes: [
+          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'warn' } },
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'error',
+        severityNumber: 17, // ERROR
+        body: {
+          stringValue: 'test error with node format',
+        },
+        attributes: [
+          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'error' } },
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .expect({
+      otel_log: {
+        severityText: 'fatal',
+        severityNumber: 21, // FATAL
+        body: {
+          stringValue: 'test fatal with node format',
+        },
+        attributes: [
+          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
+          { key: 'sentry.message.param.0', value: { stringValue: 'fatal' } },
+          { key: 'release', value: { stringValue: '1.0' } },
+          { key: 'environment', value: { stringValue: 'test' } },
+        ],
+      },
+    })
+    .start()
+    .completed();
+});
diff --git a/dev-packages/node-integration-tests/utils/assertions.ts b/dev-packages/node-integration-tests/utils/assertions.ts
index 4197c4a70844..f3925dfd493e 100644
--- a/dev-packages/node-integration-tests/utils/assertions.ts
+++ b/dev-packages/node-integration-tests/utils/assertions.ts
@@ -4,6 +4,7 @@ import type {
   Envelope,
   Event,
   SerializedCheckIn,
+  SerializedOtelLog,
   SerializedSession,
   SessionAggregates,
   TransactionEvent,
@@ -66,6 +67,12 @@ export function assertSentryClientReport(actual: ClientReport, expected: Partial
   });
 }
 
+export function assertSentryOtelLog(actual: SerializedOtelLog, expected: Partial<SerializedOtelLog>): void {
+  expect(actual).toMatchObject({
+    ...expected,
+  });
+}
+
 export function assertEnvelopeHeader(actual: Envelope[0], expected: Partial<Envelope[0]>): void {
   expect(actual).toEqual({
     event_id: expect.any(String),
diff --git a/dev-packages/node-integration-tests/utils/runner.ts b/dev-packages/node-integration-tests/utils/runner.ts
index 1d77e80bf55c..436e03a4c330 100644
--- a/dev-packages/node-integration-tests/utils/runner.ts
+++ b/dev-packages/node-integration-tests/utils/runner.ts
@@ -10,6 +10,7 @@ import type {
   Event,
   EventEnvelope,
   SerializedCheckIn,
+  SerializedOtelLog,
   SerializedSession,
   SessionAggregates,
   TransactionEvent,
@@ -20,6 +21,7 @@ import {
   assertSentryCheckIn,
   assertSentryClientReport,
   assertSentryEvent,
+  assertSentryOtelLog,
   assertSentrySession,
   assertSentrySessions,
   assertSentryTransaction,
@@ -119,6 +121,7 @@ type ExpectedSession = Partial<SerializedSession> | ((event: SerializedSession)
 type ExpectedSessions = Partial<SessionAggregates> | ((event: SessionAggregates) => void);
 type ExpectedCheckIn = Partial<SerializedCheckIn> | ((event: SerializedCheckIn) => void);
 type ExpectedClientReport = Partial<ClientReport> | ((event: ClientReport) => void);
+type ExpectedOtelLog = Partial<SerializedOtelLog> | ((event: SerializedOtelLog) => void);
 
 type Expected =
   | {
@@ -138,13 +141,17 @@ type Expected =
     }
   | {
       client_report: ExpectedClientReport;
+    }
+  | {
+      otel_log: ExpectedOtelLog;
     };
 
 type ExpectedEnvelopeHeader =
   | { event: Partial<EventEnvelope[0]> }
   | { transaction: Partial<Envelope[0]> }
   | { session: Partial<Envelope[0]> }
-  | { sessions: Partial<Envelope[0]> };
+  | { sessions: Partial<Envelope[0]> }
+  | { otel_log: Partial<Envelope[0]> };
 
 type StartResult = {
   completed(): Promise<void>;
@@ -325,6 +332,9 @@ export function createRunner(...paths: string[]) {
             } else if ('client_report' in expected) {
               expectClientReport(item[1] as ClientReport, expected.client_report);
               expectCallbackCalled();
+            } else if ('otel_log' in expected) {
+              expectOtelLog(item[1] as SerializedOtelLog, expected.otel_log);
+              expectCallbackCalled();
             } else {
               throw new Error(
                 `Unhandled expected envelope item type: ${JSON.stringify(expected)}\nItem: ${JSON.stringify(item)}`,
@@ -547,3 +557,11 @@ function expectClientReport(item: ClientReport, expected: ExpectedClientReport):
     assertSentryClientReport(item, expected);
   }
 }
+
+function expectOtelLog(item: SerializedOtelLog, expected: ExpectedOtelLog): void {
+  if (typeof expected === 'function') {
+    expected(item);
+  } else {
+    assertSentryOtelLog(item, expected);
+  }
+}

From d4e77c5241772133f76cfb29b28fa7f262ff1c88 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 17:53:30 -0400
Subject: [PATCH 08/11] fix vitest import

---
 .../node-integration-tests/suites/public-api/logger/test.ts     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dev-packages/node-integration-tests/suites/public-api/logger/test.ts b/dev-packages/node-integration-tests/suites/public-api/logger/test.ts
index cb209c8d32ba..52823d3469e1 100644
--- a/dev-packages/node-integration-tests/suites/public-api/logger/test.ts
+++ b/dev-packages/node-integration-tests/suites/public-api/logger/test.ts
@@ -1,4 +1,4 @@
-import { afterAll, expect, test } from 'vitest';
+import { afterAll, test } from 'vitest';
 import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
 
 afterAll(() => {

From fca3f1a1b9dea7355c7422b982ad10eaa8ca2d3f Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 17:55:15 -0400
Subject: [PATCH 09/11] check now

---
 .../browser-integration-tests/suites/public-api/logger/test.ts | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
index 31ef28c87057..345c51503700 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
@@ -7,12 +7,9 @@ import { getFirstSentryEnvelopeRequest, properFullEnvelopeRequestParser } from '
 sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page }) => {
   const url = await getLocalTestUrl({ testDir: __dirname });
 
-  // Get all events from the page
   const event = await getFirstSentryEnvelopeRequest<OtelLogEnvelope>(page, url, properFullEnvelopeRequestParser);
   const envelopeItems = event[1];
 
-  expect(envelopeItems.length).toBe(12);
-
   expect(envelopeItems[0]).toEqual([
     {
       type: 'otel_log',

From 78ff0ad9379965b7abc53bdf13d384876d7f86b3 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Tue, 25 Mar 2025 18:15:18 -0400
Subject: [PATCH 10/11] skip loader and cdn bundle

---
 .../suites/public-api/logger/test.ts                        | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
index 345c51503700..53a5f31ffcbb 100644
--- a/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
+++ b/dev-packages/browser-integration-tests/suites/public-api/logger/test.ts
@@ -5,6 +5,12 @@ import { sentryTest } from '../../../utils/fixtures';
 import { getFirstSentryEnvelopeRequest, properFullEnvelopeRequestParser } from '../../../utils/helpers';
 
 sentryTest('should capture all logging methods', async ({ getLocalTestUrl, page }) => {
+  const bundle = process.env.PW_BUNDLE || '';
+  // Only run this for npm package exports
+  if (bundle.startsWith('bundle') || bundle.startsWith('loader')) {
+    sentryTest.skip();
+  }
+
   const url = await getLocalTestUrl({ testDir: __dirname });
 
   const event = await getFirstSentryEnvelopeRequest<OtelLogEnvelope>(page, url, properFullEnvelopeRequestParser);

From b8a7fa6ce73619b41e9300a2357c7521dd0139a8 Mon Sep 17 00:00:00 2001
From: Abhijeet Prasad <aprasad@sentry.io>
Date: Wed, 26 Mar 2025 11:19:23 -0400
Subject: [PATCH 11/11] remove nodejs tests for now

---
 .../suites/public-api/logger/scenario.ts      |  48 ---
 .../suites/public-api/logger/test.ts          | 288 ------------------
 2 files changed, 336 deletions(-)
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts
 delete mode 100644 dev-packages/node-integration-tests/suites/public-api/logger/test.ts

diff --git a/dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts b/dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts
deleted file mode 100644
index a9b686c953ff..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/logger/scenario.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import { loggingTransport } from '@sentry-internal/node-integration-tests';
-import * as Sentry from '@sentry/node';
-
-Sentry.init({
-  dsn: 'https://public@dsn.ingest.sentry.io/1337',
-  release: '1.0',
-  environment: 'test',
-  _experiments: {
-    enableLogs: true,
-  },
-  transport: loggingTransport,
-});
-
-async function run(): Promise<void> {
-  Sentry.logger.trace('test trace');
-  Sentry.logger.debug('test debug');
-  Sentry.logger.info('test info');
-  Sentry.logger.warn('test warn');
-  Sentry.logger.error('test error');
-  Sentry.logger.fatal('test fatal');
-
-  const formattedMessage = (
-    message: string,
-    stringArg: string,
-    boolArg: boolean,
-    numberArg: number,
-  ): ReturnType<typeof Sentry.logger.fmt> => {
-    return Sentry.logger.fmt`test ${message} ${stringArg} ${boolArg} ${numberArg}`;
-  };
-
-  Sentry.logger.trace(formattedMessage('trace', 'stringArg', false, 123));
-  Sentry.logger.debug(formattedMessage('debug', 'stringArg', false, 123));
-  Sentry.logger.info(formattedMessage('info', 'stringArg', false, 123));
-  Sentry.logger.warn(formattedMessage('warn', 'stringArg', false, 123));
-  Sentry.logger.error(formattedMessage('error', 'stringArg', false, 123));
-  Sentry.logger.fatal(formattedMessage('fatal', 'stringArg', false, 123));
-
-  Sentry.logger.trace('test %s with node format', ['trace']);
-  Sentry.logger.debug('test %s with node format', ['debug']);
-  Sentry.logger.info('test %s with node format', ['info']);
-  Sentry.logger.warn('test %s with node format', ['warn']);
-  Sentry.logger.error('test %s with node format', ['error']);
-  Sentry.logger.fatal('test %s with node format', ['fatal']);
-
-  await Sentry.flush();
-}
-
-run().catch(() => undefined);
diff --git a/dev-packages/node-integration-tests/suites/public-api/logger/test.ts b/dev-packages/node-integration-tests/suites/public-api/logger/test.ts
deleted file mode 100644
index 52823d3469e1..000000000000
--- a/dev-packages/node-integration-tests/suites/public-api/logger/test.ts
+++ /dev/null
@@ -1,288 +0,0 @@
-import { afterAll, test } from 'vitest';
-import { cleanupChildProcesses, createRunner } from '../../../utils/runner';
-
-afterAll(() => {
-  cleanupChildProcesses();
-});
-
-test('should log messages with different levels and formats', async () => {
-  await createRunner(__dirname, 'scenario.ts')
-    .expect({
-      otel_log: {
-        severityText: 'trace',
-        severityNumber: 1, // TRACE
-        body: {
-          stringValue: 'test trace',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'debug',
-        severityNumber: 5, // DEBUG
-        body: {
-          stringValue: 'test debug',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'info',
-        severityNumber: 9, // INFO
-        body: {
-          stringValue: 'test info',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'warn',
-        severityNumber: 13, // WARN
-        body: {
-          stringValue: 'test warn',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'error',
-        severityNumber: 17, // ERROR
-        body: {
-          stringValue: 'test error',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'fatal',
-        severityNumber: 21, // FATAL
-        body: {
-          stringValue: 'test fatal',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'trace',
-        severityNumber: 1, // TRACE
-        body: {
-          stringValue: 'test trace stringArg false 123',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'trace' } },
-          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
-          { key: 'sentry.message.param.2', value: { boolValue: false } },
-          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'debug',
-        severityNumber: 5, // DEBUG
-        body: {
-          stringValue: 'test debug stringArg false 123',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'debug' } },
-          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
-          { key: 'sentry.message.param.2', value: { boolValue: false } },
-          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'info',
-        severityNumber: 9, // INFO
-        body: {
-          stringValue: 'test info stringArg false 123',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'info' } },
-          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
-          { key: 'sentry.message.param.2', value: { boolValue: false } },
-          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'warn',
-        severityNumber: 13, // WARN
-        body: {
-          stringValue: 'test warn stringArg false 123',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'warn' } },
-          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
-          { key: 'sentry.message.param.2', value: { boolValue: false } },
-          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'error',
-        severityNumber: 17, // ERROR
-        body: {
-          stringValue: 'test error stringArg false 123',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'error' } },
-          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
-          { key: 'sentry.message.param.2', value: { boolValue: false } },
-          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'fatal',
-        severityNumber: 21, // FATAL
-        body: {
-          stringValue: 'test fatal stringArg false 123',
-        },
-        attributes: [
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-          { key: 'sentry.message.template', value: { stringValue: 'test %s %s %s %s' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'fatal' } },
-          { key: 'sentry.message.param.1', value: { stringValue: 'stringArg' } },
-          { key: 'sentry.message.param.2', value: { boolValue: false } },
-          { key: 'sentry.message.param.3', value: { doubleValue: 123 } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'trace',
-        severityNumber: 1, // TRACE
-        body: {
-          stringValue: 'test trace with node format',
-        },
-        attributes: [
-          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'trace' } },
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'debug',
-        severityNumber: 5, // DEBUG
-        body: {
-          stringValue: 'test debug with node format',
-        },
-        attributes: [
-          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'debug' } },
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'info',
-        severityNumber: 9, // INFO
-        body: {
-          stringValue: 'test info with node format',
-        },
-        attributes: [
-          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'info' } },
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'warn',
-        severityNumber: 13, // WARN
-        body: {
-          stringValue: 'test warn with node format',
-        },
-        attributes: [
-          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'warn' } },
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'error',
-        severityNumber: 17, // ERROR
-        body: {
-          stringValue: 'test error with node format',
-        },
-        attributes: [
-          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'error' } },
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .expect({
-      otel_log: {
-        severityText: 'fatal',
-        severityNumber: 21, // FATAL
-        body: {
-          stringValue: 'test fatal with node format',
-        },
-        attributes: [
-          { key: 'sentry.message.template', value: { stringValue: 'test %s with node format' } },
-          { key: 'sentry.message.param.0', value: { stringValue: 'fatal' } },
-          { key: 'release', value: { stringValue: '1.0' } },
-          { key: 'environment', value: { stringValue: 'test' } },
-        ],
-      },
-    })
-    .start()
-    .completed();
-});