test: Add browser integration tests for logs

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://[email protected]/1337',
+  _experiments: {
+    enableLogs: true,
+  },
+});

dev-packages/browser-integration-tests/suites/public-api/logger/subject.js

@@ -0,0 +1,21 @@
+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();

dev-packages/browser-integration-tests/suites/public-api/logger/test.ts

@@ -0,0 +1,148 @@
+import { expect } from '@playwright/test';
+import type { OtelLogEnvelope } from '@sentry/core';
+
+import { sentryTest } from '../../../utils/fixtures';
+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 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,
+    },
+  ]);
+
+  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(envelopeItems[2]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'info',
+      body: { stringValue: 'test info' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
+
+  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(envelopeItems[4]).toEqual([
+    {
+      type: 'otel_log',
+    },
+    {
+      severityText: 'error',
+      body: { stringValue: 'test error' },
+      attributes: [],
+      timeUnixNano: expect.any(String),
+      traceId: expect.any(String),
+      severityNumber: 1,
+    },
+  ]);
+
+  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(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,
+    },
+  ]);
+});

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) {

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,
 };

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';