diff --git a/packages/replay-internal/src/coreHandlers/handleGlobalEvent.ts b/packages/replay-internal/src/coreHandlers/handleGlobalEvent.ts
index 88651d449fe6..a13f4d24827e 100644
--- a/packages/replay-internal/src/coreHandlers/handleGlobalEvent.ts
+++ b/packages/replay-internal/src/coreHandlers/handleGlobalEvent.ts
@@ -1,10 +1,10 @@
 import type { Event, EventHint } from '@sentry/types';
-import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import type { ReplayContainer } from '../types';
 import { isErrorEvent, isFeedbackEvent, isReplayEvent, isTransactionEvent } from '../util/eventUtils';
 import { isRrwebError } from '../util/isRrwebError';
+import { logger } from '../util/logger';
 import { addFeedbackBreadcrumb } from './util/addFeedbackBreadcrumb';
 import { shouldSampleForBufferEvent } from './util/shouldSampleForBufferEvent';
 
@@ -50,7 +50,7 @@ export function handleGlobalEventListener(replay: ReplayContainer): (event: Even
       // Unless `captureExceptions` is enabled, we want to ignore errors coming from rrweb
       // As there can be a bunch of stuff going wrong in internals there, that we don't want to bubble up to users
       if (isRrwebError(event, hint) && !replay.getOptions()._experiments.captureExceptions) {
-        DEBUG_BUILD && logger.log('[Replay] Ignoring error from rrweb internals', event);
+        DEBUG_BUILD && logger.log('Ignoring error from rrweb internals', event);
         return null;
       }
 
diff --git a/packages/replay-internal/src/coreHandlers/handleNetworkBreadcrumbs.ts b/packages/replay-internal/src/coreHandlers/handleNetworkBreadcrumbs.ts
index a31fc046b17a..8b95a1f5fabe 100644
--- a/packages/replay-internal/src/coreHandlers/handleNetworkBreadcrumbs.ts
+++ b/packages/replay-internal/src/coreHandlers/handleNetworkBreadcrumbs.ts
@@ -1,9 +1,9 @@
 import { getClient } from '@sentry/core';
 import type { Breadcrumb, BreadcrumbHint, FetchBreadcrumbData, XhrBreadcrumbData } from '@sentry/types';
-import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import type { FetchHint, ReplayContainer, ReplayNetworkOptions, XhrHint } from '../types';
+import { logger } from '../util/logger';
 import { captureFetchBreadcrumbToReplay, enrichFetchBreadcrumb } from './util/fetchUtils';
 import { captureXhrBreadcrumbToReplay, enrichXhrBreadcrumb } from './util/xhrUtils';
 
@@ -79,7 +79,7 @@ export function beforeAddNetworkBreadcrumb(
       captureFetchBreadcrumbToReplay(breadcrumb, hint, options);
     }
   } catch (e) {
-    DEBUG_BUILD && logger.warn('Error when enriching network breadcrumb');
+    DEBUG_BUILD && logger.exception(e, 'Error when enriching network breadcrumb');
   }
 }
 
diff --git a/packages/replay-internal/src/coreHandlers/util/fetchUtils.ts b/packages/replay-internal/src/coreHandlers/util/fetchUtils.ts
index b5c2c3c36305..6502206b58b6 100644
--- a/packages/replay-internal/src/coreHandlers/util/fetchUtils.ts
+++ b/packages/replay-internal/src/coreHandlers/util/fetchUtils.ts
@@ -1,6 +1,5 @@
 import { setTimeout } from '@sentry-internal/browser-utils';
 import type { Breadcrumb, FetchBreadcrumbData } from '@sentry/types';
-import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../../debug-build';
 import type {
@@ -11,6 +10,7 @@ import type {
   ReplayNetworkRequestData,
   ReplayNetworkRequestOrResponse,
 } from '../../types';
+import { logger } from '../../util/logger';
 import { addNetworkBreadcrumb } from './addNetworkBreadcrumb';
 import {
   buildNetworkRequestOrResponse,
@@ -42,7 +42,7 @@ export async function captureFetchBreadcrumbToReplay(
     const result = makeNetworkReplayBreadcrumb('resource.fetch', data);
     addNetworkBreadcrumb(options.replay, result);
   } catch (error) {
-    DEBUG_BUILD && logger.error('[Replay] Failed to capture fetch breadcrumb', error);
+    DEBUG_BUILD && logger.exception(error, 'Failed to capture fetch breadcrumb');
   }
 }
 
@@ -192,7 +192,7 @@ function getResponseData(
 
     return buildNetworkRequestOrResponse(headers, size, undefined);
   } catch (error) {
-    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize response body', error);
+    DEBUG_BUILD && logger.exception(error, 'Failed to serialize response body');
     // fallback
     return buildNetworkRequestOrResponse(headers, responseBodySize, undefined);
   }
@@ -209,7 +209,7 @@ async function _parseFetchResponseBody(response: Response): Promise<[string | un
     const text = await _tryGetResponseText(res);
     return [text];
   } catch (error) {
-    DEBUG_BUILD && logger.warn('[Replay] Failed to get text body from response', error);
+    DEBUG_BUILD && logger.exception(error, 'Failed to get text body from response');
     return [undefined, 'BODY_PARSE_ERROR'];
   }
 }
@@ -279,7 +279,7 @@ function _tryCloneResponse(response: Response): Response | void {
     return response.clone();
   } catch (error) {
     // this can throw if the response was already consumed before
-    DEBUG_BUILD && logger.warn('[Replay] Failed to clone response body', error);
+    DEBUG_BUILD && logger.exception(error, 'Failed to clone response body');
   }
 }
 
diff --git a/packages/replay-internal/src/coreHandlers/util/networkUtils.ts b/packages/replay-internal/src/coreHandlers/util/networkUtils.ts
index 06e96b7ab7df..2267fa502333 100644
--- a/packages/replay-internal/src/coreHandlers/util/networkUtils.ts
+++ b/packages/replay-internal/src/coreHandlers/util/networkUtils.ts
@@ -1,4 +1,4 @@
-import { dropUndefinedKeys, logger, stringMatchesSomePattern } from '@sentry/utils';
+import { dropUndefinedKeys, stringMatchesSomePattern } from '@sentry/utils';
 
 import { NETWORK_BODY_MAX_SIZE, WINDOW } from '../../constants';
 import { DEBUG_BUILD } from '../../debug-build';
@@ -10,6 +10,7 @@ import type {
   ReplayNetworkRequestOrResponse,
   ReplayPerformanceEntry,
 } from '../../types';
+import { logger } from '../../util/logger';
 
 /** Get the size of a body. */
 export function getBodySize(body: RequestInit['body']): number | undefined {
@@ -77,12 +78,12 @@ export function getBodyString(body: unknown): [string | undefined, NetworkMetaWa
     if (!body) {
       return [undefined];
     }
-  } catch {
-    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);
+  } catch (error) {
+    DEBUG_BUILD && logger.exception(error, 'Failed to serialize body', body);
     return [undefined, 'BODY_PARSE_ERROR'];
   }
 
-  DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);
+  DEBUG_BUILD && logger.info('Skipping network body because of body type', body);
 
   return [undefined, 'UNPARSEABLE_BODY_TYPE'];
 }
diff --git a/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts b/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts
index b86e2d2991a9..52b6cafdfec7 100644
--- a/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts
+++ b/packages/replay-internal/src/coreHandlers/util/xhrUtils.ts
@@ -1,6 +1,5 @@
 import { SENTRY_XHR_DATA_KEY } from '@sentry-internal/browser-utils';
 import type { Breadcrumb, XhrBreadcrumbData } from '@sentry/types';
-import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../../debug-build';
 import type {
@@ -10,6 +9,7 @@ import type {
   ReplayNetworkRequestData,
   XhrHint,
 } from '../../types';
+import { logger } from '../../util/logger';
 import { addNetworkBreadcrumb } from './addNetworkBreadcrumb';
 import {
   buildNetworkRequestOrResponse,
@@ -39,7 +39,7 @@ export async function captureXhrBreadcrumbToReplay(
     const result = makeNetworkReplayBreadcrumb('resource.xhr', data);
     addNetworkBreadcrumb(options.replay, result);
   } catch (error) {
-    DEBUG_BUILD && logger.error('[Replay] Failed to capture xhr breadcrumb', error);
+    DEBUG_BUILD && logger.exception(error, 'Failed to capture xhr breadcrumb');
   }
 }
 
@@ -161,7 +161,7 @@ function _getXhrResponseBody(xhr: XMLHttpRequest): [string | undefined, NetworkM
     errors.push(e);
   }
 
-  DEBUG_BUILD && logger.warn('[Replay] Failed to get xhr response body', ...errors);
+  DEBUG_BUILD && logger.warn('Failed to get xhr response body', ...errors);
 
   return [undefined];
 }
@@ -197,12 +197,12 @@ export function _parseXhrResponse(
     if (!body) {
       return [undefined];
     }
-  } catch {
-    DEBUG_BUILD && logger.warn('[Replay] Failed to serialize body', body);
+  } catch (error) {
+    DEBUG_BUILD && logger.exception(error, 'Failed to serialize body', body);
     return [undefined, 'BODY_PARSE_ERROR'];
   }
 
-  DEBUG_BUILD && logger.info('[Replay] Skipping network body because of body type', body);
+  DEBUG_BUILD && logger.info('Skipping network body because of body type', body);
 
   return [undefined, 'UNPARSEABLE_BODY_TYPE'];
 }
diff --git a/packages/replay-internal/src/eventBuffer/EventBufferCompressionWorker.ts b/packages/replay-internal/src/eventBuffer/EventBufferCompressionWorker.ts
index 21206ea652ac..90a54bbf07f3 100644
--- a/packages/replay-internal/src/eventBuffer/EventBufferCompressionWorker.ts
+++ b/packages/replay-internal/src/eventBuffer/EventBufferCompressionWorker.ts
@@ -1,9 +1,9 @@
 import type { ReplayRecordingData } from '@sentry/types';
 
-import { logger } from '@sentry/utils';
 import { REPLAY_MAX_EVENT_BUFFER_SIZE } from '../constants';
 import { DEBUG_BUILD } from '../debug-build';
 import type { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';
+import { logger } from '../util/logger';
 import { timestampToMs } from '../util/timestamp';
 import { WorkerHandler } from './WorkerHandler';
 import { EventBufferSizeExceededError } from './error';
@@ -88,7 +88,7 @@ export class EventBufferCompressionWorker implements EventBuffer {
 
     // We do not wait on this, as we assume the order of messages is consistent for the worker
     this._worker.postMessage('clear').then(null, e => {
-      DEBUG_BUILD && logger.warn('[Replay] Sending "clear" message to worker failed', e);
+      DEBUG_BUILD && logger.exception(e, 'Sending "clear" message to worker failed', e);
     });
   }
 
diff --git a/packages/replay-internal/src/eventBuffer/EventBufferProxy.ts b/packages/replay-internal/src/eventBuffer/EventBufferProxy.ts
index af6645a89e69..413bb6fb6372 100644
--- a/packages/replay-internal/src/eventBuffer/EventBufferProxy.ts
+++ b/packages/replay-internal/src/eventBuffer/EventBufferProxy.ts
@@ -1,9 +1,8 @@
 import type { ReplayRecordingData } from '@sentry/types';
-import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import type { AddEventResult, EventBuffer, EventBufferType, RecordingEvent } from '../types';
-import { logInfo } from '../util/log';
+import { logger } from '../util/logger';
 import { EventBufferArray } from './EventBufferArray';
 import { EventBufferCompressionWorker } from './EventBufferCompressionWorker';
 
@@ -90,7 +89,7 @@ export class EventBufferProxy implements EventBuffer {
     } catch (error) {
       // If the worker fails to load, we fall back to the simple buffer.
       // Nothing more to do from our side here
-      logInfo('[Replay] Failed to load the compression worker, falling back to simple buffer');
+      DEBUG_BUILD && logger.exception(error, 'Failed to load the compression worker, falling back to simple buffer');
       return;
     }
 
@@ -117,7 +116,7 @@ export class EventBufferProxy implements EventBuffer {
     try {
       await Promise.all(addEventPromises);
     } catch (error) {
-      DEBUG_BUILD && logger.warn('[Replay] Failed to add events when switching buffers.', error);
+      DEBUG_BUILD && logger.exception(error, 'Failed to add events when switching buffers.');
     }
   }
 }
diff --git a/packages/replay-internal/src/eventBuffer/WorkerHandler.ts b/packages/replay-internal/src/eventBuffer/WorkerHandler.ts
index 1014521e652f..2ccc3ee94b3c 100644
--- a/packages/replay-internal/src/eventBuffer/WorkerHandler.ts
+++ b/packages/replay-internal/src/eventBuffer/WorkerHandler.ts
@@ -1,8 +1,6 @@
-import { logger } from '@sentry/utils';
-
 import { DEBUG_BUILD } from '../debug-build';
 import type { WorkerRequest, WorkerResponse } from '../types';
-import { logInfo } from '../util/log';
+import { logger } from '../util/logger';
 
 /**
  * Event buffer that uses a web worker to compress events.
@@ -57,7 +55,7 @@ export class WorkerHandler {
    * Destroy the worker.
    */
   public destroy(): void {
-    logInfo('[Replay] Destroying compression worker');
+    DEBUG_BUILD && logger.info('Destroying compression worker');
     this._worker.terminate();
   }
 
@@ -85,7 +83,7 @@ export class WorkerHandler {
 
         if (!response.success) {
           // TODO: Do some error handling, not sure what
-          DEBUG_BUILD && logger.error('[Replay]', response.response);
+          DEBUG_BUILD && logger.error('Error in compression worker: ', response.response);
 
           reject(new Error('Error in compression worker'));
           return;
diff --git a/packages/replay-internal/src/eventBuffer/index.ts b/packages/replay-internal/src/eventBuffer/index.ts
index 741cb5dedc91..bc000da5db7e 100644
--- a/packages/replay-internal/src/eventBuffer/index.ts
+++ b/packages/replay-internal/src/eventBuffer/index.ts
@@ -1,7 +1,8 @@
 import { getWorkerURL } from '@sentry-internal/replay-worker';
 
+import { DEBUG_BUILD } from '../debug-build';
 import type { EventBuffer } from '../types';
-import { logInfo } from '../util/log';
+import { logger } from '../util/logger';
 import { EventBufferArray } from './EventBufferArray';
 import { EventBufferProxy } from './EventBufferProxy';
 
@@ -32,7 +33,7 @@ export function createEventBuffer({
     }
   }
 
-  logInfo('[Replay] Using simple buffer');
+  DEBUG_BUILD && logger.info('Using simple buffer');
   return new EventBufferArray();
 }
 
@@ -44,11 +45,11 @@ function _loadWorker(customWorkerUrl?: string): EventBufferProxy | void {
       return;
     }
 
-    logInfo(`[Replay] Using compression worker${customWorkerUrl ? ` from ${customWorkerUrl}` : ''}`);
+    DEBUG_BUILD && logger.info(`Using compression worker${customWorkerUrl ? ` from ${customWorkerUrl}` : ''}`);
     const worker = new Worker(workerUrl);
     return new EventBufferProxy(worker);
   } catch (error) {
-    logInfo('[Replay] Failed to create compression worker');
+    DEBUG_BUILD && logger.exception(error, 'Failed to create compression worker');
     // Fall back to use simple event buffer array
   }
 }
diff --git a/packages/replay-internal/src/replay.ts b/packages/replay-internal/src/replay.ts
index f42d6ef6964a..b48ac787543b 100644
--- a/packages/replay-internal/src/replay.ts
+++ b/packages/replay-internal/src/replay.ts
@@ -1,15 +1,8 @@
 /* eslint-disable max-lines */ // TODO: We might want to split this file up
 import { EventType, record } from '@sentry-internal/rrweb';
-import {
-  SEMANTIC_ATTRIBUTE_SENTRY_SOURCE,
-  captureException,
-  getActiveSpan,
-  getClient,
-  getRootSpan,
-  spanToJSON,
-} from '@sentry/core';
+import { SEMANTIC_ATTRIBUTE_SENTRY_SOURCE, getActiveSpan, getClient, getRootSpan, spanToJSON } from '@sentry/core';
 import type { ReplayRecordingMode, Span } from '@sentry/types';
-import { logger } from '@sentry/utils';
+import { logger } from './util/logger';
 
 import {
   BUFFER_CHECKOUT_TIME,
@@ -60,7 +53,6 @@ import { debounce } from './util/debounce';
 import { getHandleRecordingEmit } from './util/handleRecordingEmit';
 import { isExpired } from './util/isExpired';
 import { isSessionExpired } from './util/isSessionExpired';
-import { logInfo, logInfoNextTick } from './util/log';
 import { sendReplay } from './util/sendReplay';
 import type { SKIPPED } from './util/throttle';
 import { THROTTLED, throttle } from './util/throttle';
@@ -212,6 +204,15 @@ export class ReplayContainer implements ReplayContainerInterface {
     if (slowClickConfig) {
       this.clickDetector = new ClickDetector(this, slowClickConfig);
     }
+
+    // Configure replay logger w/ experimental options
+    if (DEBUG_BUILD) {
+      const experiments = options._experiments;
+      logger.setConfig({
+        captureExceptions: !!experiments.captureExceptions,
+        traceInternals: !!experiments.traceInternals,
+      });
+    }
   }
 
   /** Get the event context. */
@@ -243,11 +244,7 @@ export class ReplayContainer implements ReplayContainerInterface {
 
   /** A wrapper to conditionally capture exceptions. */
   public handleException(error: unknown): void {
-    DEBUG_BUILD && logger.error('[Replay]', error);
-
-    if (DEBUG_BUILD && this._options._experiments && this._options._experiments.captureExceptions) {
-      captureException(error);
-    }
+    DEBUG_BUILD && logger.exception(error);
   }
 
   /**
@@ -273,7 +270,7 @@ export class ReplayContainer implements ReplayContainerInterface {
 
     if (!this.session) {
       // This should not happen, something wrong has occurred
-      this.handleException(new Error('Unable to initialize and create session'));
+      DEBUG_BUILD && logger.exception(new Error('Unable to initialize and create session'));
       return;
     }
 
@@ -287,10 +284,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     // In this case, we still want to continue in `session` recording mode
     this.recordingMode = this.session.sampled === 'buffer' && this.session.segmentId === 0 ? 'buffer' : 'session';
 
-    logInfoNextTick(
-      `[Replay] Starting replay in ${this.recordingMode} mode`,
-      this._options._experiments.traceInternals,
-    );
+    DEBUG_BUILD && logger.infoTick(`Starting replay in ${this.recordingMode} mode`);
 
     this._initializeRecording();
   }
@@ -304,16 +298,16 @@ export class ReplayContainer implements ReplayContainerInterface {
    */
   public start(): void {
     if (this._isEnabled && this.recordingMode === 'session') {
-      DEBUG_BUILD && logger.info('[Replay] Recording is already in progress');
+      DEBUG_BUILD && logger.info('Recording is already in progress');
       return;
     }
 
     if (this._isEnabled && this.recordingMode === 'buffer') {
-      DEBUG_BUILD && logger.info('[Replay] Buffering is in progress, call `flush()` to save the replay');
+      DEBUG_BUILD && logger.info('Buffering is in progress, call `flush()` to save the replay');
       return;
     }
 
-    logInfoNextTick('[Replay] Starting replay in session mode', this._options._experiments.traceInternals);
+    DEBUG_BUILD && logger.infoTick('Starting replay in session mode');
 
     // Required as user activity is initially set in
     // constructor, so if `start()` is called after
@@ -325,7 +319,6 @@ export class ReplayContainer implements ReplayContainerInterface {
       {
         maxReplayDuration: this._options.maxReplayDuration,
         sessionIdleExpire: this.timeouts.sessionIdleExpire,
-        traceInternals: this._options._experiments.traceInternals,
       },
       {
         stickySession: this._options.stickySession,
@@ -346,17 +339,16 @@ export class ReplayContainer implements ReplayContainerInterface {
    */
   public startBuffering(): void {
     if (this._isEnabled) {
-      DEBUG_BUILD && logger.info('[Replay] Buffering is in progress, call `flush()` to save the replay');
+      DEBUG_BUILD && logger.info('Buffering is in progress, call `flush()` to save the replay');
       return;
     }
 
-    logInfoNextTick('[Replay] Starting replay in buffer mode', this._options._experiments.traceInternals);
+    DEBUG_BUILD && logger.infoTick('Starting replay in buffer mode');
 
     const session = loadOrCreateSession(
       {
         sessionIdleExpire: this.timeouts.sessionIdleExpire,
         maxReplayDuration: this._options.maxReplayDuration,
-        traceInternals: this._options._experiments.traceInternals,
       },
       {
         stickySession: this._options.stickySession,
@@ -436,10 +428,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     this._isEnabled = false;
 
     try {
-      logInfo(
-        `[Replay] Stopping Replay${reason ? ` triggered by ${reason}` : ''}`,
-        this._options._experiments.traceInternals,
-      );
+      DEBUG_BUILD && logger.info(`Stopping Replay${reason ? ` triggered by ${reason}` : ''}`);
 
       this._removeListeners();
       this.stopRecording();
@@ -476,7 +465,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     this._isPaused = true;
     this.stopRecording();
 
-    logInfo('[Replay] Pausing replay', this._options._experiments.traceInternals);
+    DEBUG_BUILD && logger.info('Pausing replay');
   }
 
   /**
@@ -493,7 +482,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     this._isPaused = false;
     this.startRecording();
 
-    logInfo('[Replay] Resuming replay', this._options._experiments.traceInternals);
+    DEBUG_BUILD && logger.info('Resuming replay');
   }
 
   /**
@@ -510,7 +499,7 @@ export class ReplayContainer implements ReplayContainerInterface {
 
     const activityTime = Date.now();
 
-    logInfo('[Replay] Converting buffer to session', this._options._experiments.traceInternals);
+    DEBUG_BUILD && logger.info('Converting buffer to session');
 
     // Allow flush to complete before resuming as a session recording, otherwise
     // the checkout from `startRecording` may be included in the payload.
@@ -798,7 +787,6 @@ export class ReplayContainer implements ReplayContainerInterface {
       {
         sessionIdleExpire: this.timeouts.sessionIdleExpire,
         maxReplayDuration: this._options.maxReplayDuration,
-        traceInternals: this._options._experiments.traceInternals,
         previousSessionId,
       },
       {
@@ -990,7 +978,7 @@ export class ReplayContainer implements ReplayContainerInterface {
       // If the user has come back to the page within SESSION_IDLE_PAUSE_DURATION
       // ms, we will re-use the existing session, otherwise create a new
       // session
-      logInfo('[Replay] Document has become active, but session has expired');
+      DEBUG_BUILD && logger.info('Document has become active, but session has expired');
       return;
     }
 
@@ -1106,7 +1094,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     const replayId = this.getSessionId();
 
     if (!this.session || !this.eventBuffer || !replayId) {
-      DEBUG_BUILD && logger.error('[Replay] No session or eventBuffer found to flush.');
+      DEBUG_BUILD && logger.error('No session or eventBuffer found to flush.');
       return;
     }
 
@@ -1198,7 +1186,7 @@ export class ReplayContainer implements ReplayContainerInterface {
     }
 
     if (!this.checkAndHandleExpiredSession()) {
-      DEBUG_BUILD && logger.error('[Replay] Attempting to finish replay event after session expired.');
+      DEBUG_BUILD && logger.error('Attempting to finish replay event after session expired.');
       return;
     }
 
@@ -1219,12 +1207,12 @@ export class ReplayContainer implements ReplayContainerInterface {
     const tooShort = duration < this._options.minReplayDuration;
     const tooLong = duration > this._options.maxReplayDuration + 5_000;
     if (tooShort || tooLong) {
-      logInfo(
-        `[Replay] Session duration (${Math.floor(duration / 1000)}s) is too ${
-          tooShort ? 'short' : 'long'
-        }, not sending replay.`,
-        this._options._experiments.traceInternals,
-      );
+      DEBUG_BUILD &&
+        logger.info(
+          `Session duration (${Math.floor(duration / 1000)}s) is too ${
+            tooShort ? 'short' : 'long'
+          }, not sending replay.`,
+        );
 
       if (tooShort) {
         this._debouncedFlush();
@@ -1234,7 +1222,7 @@ export class ReplayContainer implements ReplayContainerInterface {
 
     const eventBuffer = this.eventBuffer;
     if (eventBuffer && this.session.segmentId === 0 && !eventBuffer.hasCheckout) {
-      logInfo('[Replay] Flushing initial segment without checkout.', this._options._experiments.traceInternals);
+      DEBUG_BUILD && logger.info('Flushing initial segment without checkout.');
       // TODO FN: Evaluate if we want to stop here, or remove this again?
     }
 
diff --git a/packages/replay-internal/src/session/fetchSession.ts b/packages/replay-internal/src/session/fetchSession.ts
index 43e162b5f3d6..031605bfde87 100644
--- a/packages/replay-internal/src/session/fetchSession.ts
+++ b/packages/replay-internal/src/session/fetchSession.ts
@@ -1,13 +1,14 @@
 import { REPLAY_SESSION_KEY, WINDOW } from '../constants';
+import { DEBUG_BUILD } from '../debug-build';
 import type { Session } from '../types';
 import { hasSessionStorage } from '../util/hasSessionStorage';
-import { logInfoNextTick } from '../util/log';
+import { logger } from '../util/logger';
 import { makeSession } from './Session';
 
 /**
  * Fetches a session from storage
  */
-export function fetchSession(traceInternals?: boolean): Session | null {
+export function fetchSession(): Session | null {
   if (!hasSessionStorage()) {
     return null;
   }
@@ -22,7 +23,7 @@ export function fetchSession(traceInternals?: boolean): Session | null {
 
     const sessionObj = JSON.parse(sessionStringFromStorage) as Session;
 
-    logInfoNextTick('[Replay] Loading existing session', traceInternals);
+    DEBUG_BUILD && logger.infoTick('Loading existing session');
 
     return makeSession(sessionObj);
   } catch {
diff --git a/packages/replay-internal/src/session/loadOrCreateSession.ts b/packages/replay-internal/src/session/loadOrCreateSession.ts
index 1e1ac7664d40..d37c51590d54 100644
--- a/packages/replay-internal/src/session/loadOrCreateSession.ts
+++ b/packages/replay-internal/src/session/loadOrCreateSession.ts
@@ -1,5 +1,6 @@
+import { DEBUG_BUILD } from '../debug-build';
 import type { Session, SessionOptions } from '../types';
-import { logInfoNextTick } from '../util/log';
+import { logger } from '../util/logger';
 import { createSession } from './createSession';
 import { fetchSession } from './fetchSession';
 import { shouldRefreshSession } from './shouldRefreshSession';
@@ -10,23 +11,21 @@ import { shouldRefreshSession } from './shouldRefreshSession';
  */
 export function loadOrCreateSession(
   {
-    traceInternals,
     sessionIdleExpire,
     maxReplayDuration,
     previousSessionId,
   }: {
     sessionIdleExpire: number;
     maxReplayDuration: number;
-    traceInternals?: boolean;
     previousSessionId?: string;
   },
   sessionOptions: SessionOptions,
 ): Session {
-  const existingSession = sessionOptions.stickySession && fetchSession(traceInternals);
+  const existingSession = sessionOptions.stickySession && fetchSession();
 
   // No session exists yet, just create a new one
   if (!existingSession) {
-    logInfoNextTick('[Replay] Creating new session', traceInternals);
+    DEBUG_BUILD && logger.infoTick('Creating new session');
     return createSession(sessionOptions, { previousSessionId });
   }
 
@@ -34,6 +33,6 @@ export function loadOrCreateSession(
     return existingSession;
   }
 
-  logInfoNextTick('[Replay] Session in sessionStorage is expired, creating new one...');
+  DEBUG_BUILD && logger.infoTick('Session in sessionStorage is expired, creating new one...');
   return createSession(sessionOptions, { previousSessionId: existingSession.id });
 }
diff --git a/packages/replay-internal/src/util/addEvent.ts b/packages/replay-internal/src/util/addEvent.ts
index f397ea0564f6..700627cf954f 100644
--- a/packages/replay-internal/src/util/addEvent.ts
+++ b/packages/replay-internal/src/util/addEvent.ts
@@ -1,11 +1,10 @@
 import { EventType } from '@sentry-internal/rrweb';
 import { getClient } from '@sentry/core';
-import { logger } from '@sentry/utils';
 
 import { DEBUG_BUILD } from '../debug-build';
 import { EventBufferSizeExceededError } from '../eventBuffer/error';
 import type { AddEventResult, RecordingEvent, ReplayContainer, ReplayFrameEvent, ReplayPluginOptions } from '../types';
-import { logInfoNextTick } from './log';
+import { logger } from './logger';
 import { timestampToMs } from './timestamp';
 
 function isCustomEvent(event: RecordingEvent): event is ReplayFrameEvent {
@@ -109,10 +108,8 @@ export function shouldAddEvent(replay: ReplayContainer, event: RecordingEvent):
 
   // Throw out events that are +60min from the initial timestamp
   if (timestampInMs > replay.getContext().initialTimestamp + replay.getOptions().maxReplayDuration) {
-    logInfoNextTick(
-      `[Replay] Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`,
-      replay.getOptions()._experiments.traceInternals,
-    );
+    DEBUG_BUILD &&
+      logger.infoTick(`Skipping event with timestamp ${timestampInMs} because it is after maxReplayDuration`);
     return false;
   }
 
@@ -129,7 +126,7 @@ function maybeApplyCallback(
     }
   } catch (error) {
     DEBUG_BUILD &&
-      logger.error('[Replay] An error occured in the `beforeAddRecordingEvent` callback, skipping the event...', error);
+      logger.exception(error, 'An error occured in the `beforeAddRecordingEvent` callback, skipping the event...');
     return null;
   }
 
diff --git a/packages/replay-internal/src/util/handleRecordingEmit.ts b/packages/replay-internal/src/util/handleRecordingEmit.ts
index eaec29be261a..6b87845d793f 100644
--- a/packages/replay-internal/src/util/handleRecordingEmit.ts
+++ b/packages/replay-internal/src/util/handleRecordingEmit.ts
@@ -1,12 +1,11 @@
 import { EventType } from '@sentry-internal/rrweb';
-import { logger } from '@sentry/utils';
 
 import { updateClickDetectorForRecordingEvent } from '../coreHandlers/handleClick';
 import { DEBUG_BUILD } from '../debug-build';
 import { saveSession } from '../session/saveSession';
 import type { RecordingEvent, ReplayContainer, ReplayOptionFrameEvent } from '../types';
 import { addEventSync } from './addEvent';
-import { logInfo } from './log';
+import { logger } from './logger';
 
 type RecordingEmitCallback = (event: RecordingEvent, isCheckout?: boolean) => void;
 
@@ -21,7 +20,7 @@ export function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCa
   return (event: RecordingEvent, _isCheckout?: boolean) => {
     // If this is false, it means session is expired, create and a new session and wait for checkout
     if (!replay.checkAndHandleExpiredSession()) {
-      DEBUG_BUILD && logger.warn('[Replay] Received replay event after session expired.');
+      DEBUG_BUILD && logger.warn('Received replay event after session expired.');
 
       return;
     }
@@ -82,10 +81,8 @@ export function getHandleRecordingEmit(replay: ReplayContainer): RecordingEmitCa
       if (replay.recordingMode === 'buffer' && replay.session && replay.eventBuffer) {
         const earliestEvent = replay.eventBuffer.getEarliestTimestamp();
         if (earliestEvent) {
-          logInfo(
-            `[Replay] Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`,
-            replay.getOptions()._experiments.traceInternals,
-          );
+          DEBUG_BUILD &&
+            logger.info(`Updating session start time to earliest event in buffer to ${new Date(earliestEvent)}`);
 
           replay.session.started = earliestEvent;
 
diff --git a/packages/replay-internal/src/util/log.ts b/packages/replay-internal/src/util/log.ts
deleted file mode 100644
index c847a093f02f..000000000000
--- a/packages/replay-internal/src/util/log.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-import { setTimeout } from '@sentry-internal/browser-utils';
-import { addBreadcrumb } from '@sentry/core';
-import { logger } from '@sentry/utils';
-
-import { DEBUG_BUILD } from '../debug-build';
-
-/**
- * Log a message in debug mode, and add a breadcrumb when _experiment.traceInternals is enabled.
- */
-export function logInfo(message: string, shouldAddBreadcrumb?: boolean): void {
-  if (!DEBUG_BUILD) {
-    return;
-  }
-
-  logger.info(message);
-
-  if (shouldAddBreadcrumb) {
-    addLogBreadcrumb(message);
-  }
-}
-
-/**
- * Log a message, and add a breadcrumb in the next tick.
- * This is necessary when the breadcrumb may be added before the replay is initialized.
- */
-export function logInfoNextTick(message: string, shouldAddBreadcrumb?: boolean): void {
-  if (!DEBUG_BUILD) {
-    return;
-  }
-
-  logger.info(message);
-
-  if (shouldAddBreadcrumb) {
-    // Wait a tick here to avoid race conditions for some initial logs
-    // which may be added before replay is initialized
-    setTimeout(() => {
-      addLogBreadcrumb(message);
-    }, 0);
-  }
-}
-
-function addLogBreadcrumb(message: string): void {
-  addBreadcrumb(
-    {
-      category: 'console',
-      data: {
-        logger: 'replay',
-      },
-      level: 'info',
-      message,
-    },
-    { level: 'info' },
-  );
-}
diff --git a/packages/replay-internal/src/util/logger.ts b/packages/replay-internal/src/util/logger.ts
new file mode 100644
index 000000000000..80445409164b
--- /dev/null
+++ b/packages/replay-internal/src/util/logger.ts
@@ -0,0 +1,105 @@
+import { addBreadcrumb, captureException } from '@sentry/core';
+import type { ConsoleLevel, SeverityLevel } from '@sentry/types';
+import { logger as coreLogger } from '@sentry/utils';
+
+import { DEBUG_BUILD } from '../debug-build';
+
+type ReplayConsoleLevels = Extract<ConsoleLevel, 'info' | 'warn' | 'error' | 'log'>;
+const CONSOLE_LEVELS: readonly ReplayConsoleLevels[] = ['info', 'warn', 'error', 'log'] as const;
+const PREFIX = '[Replay] ';
+
+type LoggerMethod = (...args: unknown[]) => void;
+type LoggerConsoleMethods = Record<ReplayConsoleLevels, LoggerMethod>;
+
+interface LoggerConfig {
+  captureExceptions: boolean;
+  traceInternals: boolean;
+}
+
+interface ReplayLogger extends LoggerConsoleMethods {
+  /**
+   * Calls `logger.info` but saves breadcrumb in the next tick due to race
+   * conditions before replay is initialized.
+   */
+  infoTick: LoggerMethod;
+  /**
+   * Captures exceptions (`Error`) if "capture internal exceptions" is enabled
+   */
+  exception: LoggerMethod;
+  /**
+   * Configures the logger with additional debugging behavior
+   */
+  setConfig(config: LoggerConfig): void;
+}
+
+function _addBreadcrumb(message: unknown, level: SeverityLevel = 'info'): void {
+  addBreadcrumb(
+    {
+      category: 'console',
+      data: {
+        logger: 'replay',
+      },
+      level,
+      message: `${PREFIX}${message}`,
+    },
+    { level },
+  );
+}
+
+function makeReplayLogger(): ReplayLogger {
+  let _capture = false;
+  let _trace = false;
+
+  const _logger: Partial<ReplayLogger> = {
+    exception: () => undefined,
+    infoTick: () => undefined,
+    setConfig: (opts: LoggerConfig) => {
+      _capture = opts.captureExceptions;
+      _trace = opts.traceInternals;
+    },
+  };
+
+  if (DEBUG_BUILD) {
+    CONSOLE_LEVELS.forEach(name => {
+      _logger[name] = (...args: unknown[]) => {
+        coreLogger[name](PREFIX, ...args);
+        if (_trace) {
+          _addBreadcrumb(args[0]);
+        }
+      };
+    });
+
+    _logger.exception = (error: unknown, ...message: unknown[]) => {
+      if (_logger.error) {
+        _logger.error(...message);
+      }
+
+      coreLogger.error(PREFIX, error);
+
+      if (_capture) {
+        captureException(error);
+      } else if (_trace) {
+        // No need for a breadcrumb is `_capture` is enabled since it should be
+        // captured as an exception
+        _addBreadcrumb(error);
+      }
+    };
+
+    _logger.infoTick = (...args: unknown[]) => {
+      coreLogger.info(PREFIX, ...args);
+      if (_trace) {
+        // Wait a tick here to avoid race conditions for some initial logs
+        // which may be added before replay is initialized
+        setTimeout(() => _addBreadcrumb(args[0]), 0);
+      }
+    };
+  } else {
+    CONSOLE_LEVELS.forEach(name => {
+      _logger[name] = () => undefined;
+    });
+  }
+
+  return _logger as ReplayLogger;
+}
+
+export const logger = makeReplayLogger();
diff --git a/packages/replay-internal/src/util/sendReplayRequest.ts b/packages/replay-internal/src/util/sendReplayRequest.ts
index 03945bb479af..a623771af75b 100644
--- a/packages/replay-internal/src/util/sendReplayRequest.ts
+++ b/packages/replay-internal/src/util/sendReplayRequest.ts
@@ -5,9 +5,10 @@ import { resolvedSyncPromise } from '@sentry/utils';
 import { isRateLimited, updateRateLimits } from '@sentry/utils';
 
 import { REPLAY_EVENT_NAME, UNABLE_TO_SEND_REPLAY } from '../constants';
+import { DEBUG_BUILD } from '../debug-build';
 import type { SendReplayData } from '../types';
 import { createReplayEnvelope } from './createReplayEnvelope';
-import { logInfo } from './log';
+import { logger } from './logger';
 import { prepareRecordingData } from './prepareRecordingData';
 import { prepareReplayEvent } from './prepareReplayEvent';
 
@@ -57,7 +58,7 @@ export async function sendReplayRequest({
   if (!replayEvent) {
     // Taken from baseclient's `_processEvent` method, where this is handled for errors/transactions
     client.recordDroppedEvent('event_processor', 'replay', baseEvent);
-    logInfo('An event processor returned `null`, will not send event.');
+    DEBUG_BUILD && logger.info('An event processor returned `null`, will not send event.');
     return resolvedSyncPromise({});
   }
 
diff --git a/packages/replay-internal/test/integration/flush.test.ts b/packages/replay-internal/test/integration/flush.test.ts
index 999811de0a81..ffc0a83bb141 100644
--- a/packages/replay-internal/test/integration/flush.test.ts
+++ b/packages/replay-internal/test/integration/flush.test.ts
@@ -19,6 +19,7 @@ import { clearSession } from '../../src/session/clearSession';
 import type { EventBuffer } from '../../src/types';
 import { createPerformanceEntries } from '../../src/util/createPerformanceEntries';
 import { createPerformanceSpans } from '../../src/util/createPerformanceSpans';
+import { logger } from '../../src/util/logger';
 import * as SendReplay from '../../src/util/sendReplay';
 import { BASE_TIMESTAMP, mockRrweb, mockSdk } from '../index';
 import type { DomHandler } from '../types';
@@ -335,7 +336,7 @@ describe('Integration | flush', () => {
   });
 
   it('logs warning if flushing initial segment without checkout', async () => {
-    replay.getOptions()._experiments.traceInternals = true;
+    logger.setConfig({ traceInternals: true });
 
     sessionStorage.clear();
     clearSession(replay);
@@ -408,11 +409,11 @@ describe('Integration | flush', () => {
       },
     ]);
 
-    replay.getOptions()._experiments.traceInternals = false;
+    logger.setConfig({ traceInternals: false });
   });
 
   it('logs warning if adding event that is after maxReplayDuration', async () => {
-    replay.getOptions()._experiments.traceInternals = true;
+    logger.setConfig({ traceInternals: true });
 
     const spyLogger = vi.spyOn(SentryUtils.logger, 'info');
 
@@ -440,12 +441,13 @@ describe('Integration | flush', () => {
     expect(mockSendReplay).toHaveBeenCalledTimes(0);
 
     expect(spyLogger).toHaveBeenLastCalledWith(
-      `[Replay] Skipping event with timestamp ${
+      '[Replay] ',
+      `Skipping event with timestamp ${
         BASE_TIMESTAMP + MAX_REPLAY_DURATION + 100
       } because it is after maxReplayDuration`,
     );
 
-    replay.getOptions()._experiments.traceInternals = false;
+    logger.setConfig({ traceInternals: false });
     spyLogger.mockRestore();
   });