feat(node): Move default option handling from init to NodeClient

packages/core/src/index.ts

@@ -160,7 +160,7 @@ export {
   isVueViewModel,
 } from './utils-hoist/is';
 export { isBrowser } from './utils-hoist/isBrowser';
-export { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods } from './utils-hoist/logger';
+export { CONSOLE_LEVELS, consoleSandbox, logger, originalConsoleMethods, enableLogger } from './utils-hoist/logger';
 export type { Logger } from './utils-hoist/logger';
 export {
   addContextToFrame,

packages/core/src/sdk.ts

@@ -1,8 +1,7 @@
 import type { Client } from './client';
 import { getCurrentScope } from './currentScopes';
-import { DEBUG_BUILD } from './debug-build';
 import type { ClientOptions } from './types-hoist/options';
-import { consoleSandbox, logger } from './utils-hoist/logger';
+import { enableLogger } from './utils-hoist/logger';
 
 /** A class object that can instantiate Client objects. */
 export type ClientClass<F extends Client, O extends ClientOptions> = new (options: O) => F;
@@ -14,25 +13,14 @@ export type ClientClass<F extends Client, O extends ClientOptions> = new (option
  * @param clientClass The client class to instantiate.
  * @param options Options to pass to the client.
  */
-export function initAndBind<F extends Client, O extends ClientOptions>(
-  clientClass: ClientClass<F, O>,
-  options: O,
-): Client {
-  if (options.debug === true) {
-    if (DEBUG_BUILD) {
-      logger.enable();
-    } else {
-      // use `console.warn` rather than `logger.warn` since by non-debug bundles have all `logger.x` statements stripped
-      consoleSandbox(() => {
-        // eslint-disable-next-line no-console
-        console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');
-      });
-    }
+export function initAndBind<F extends Client, O extends ClientOptions>(ClientClass: ClientClass<F, O>, options: O): F {
+  if (options.debug) {
+    enableLogger();
   }
   const scope = getCurrentScope();
   scope.update(options.initialScope);
 
-  const client = new clientClass(options);
+  const client = new ClientClass(options);
   setCurrentClient(client);
   client.init();
   return client;

packages/core/src/utils-hoist/logger.ts

@@ -100,3 +100,16 @@ function makeLogger(): Logger {
  * The logger is a singleton on the carrier, to ensure that a consistent logger is used throughout the SDK.
  */
 export const logger = getGlobalSingleton('logger', makeLogger);
+
+/** Enables the logger, or log a warning if DEBUG_BUILD is false. */
+export function enableLogger(): void {
+  if (DEBUG_BUILD) {
+    logger.enable();
+  } else {
+    // use `console.warn` rather than `logger.warn` since non-debug bundles have all `logger.x` statements stripped
+    consoleSandbox(() => {
+      // eslint-disable-next-line no-console
+      console.warn('[Sentry] Cannot initialize SDK with `debug` option using a non-debug bundle.');
+    });
+  }
+}

packages/node/src/sdk/client.ts

@@ -3,12 +3,19 @@ import type { Tracer } from '@opentelemetry/api';
 import { trace } from '@opentelemetry/api';
 import { registerInstrumentations } from '@opentelemetry/instrumentation';
 import type { BasicTracerProvider } from '@opentelemetry/sdk-trace-base';
-import type { DynamicSamplingContext, Scope, ServerRuntimeClientOptions, TraceContext } from '@sentry/core';
+import type { DynamicSamplingContext, Scope, TraceContext } from '@sentry/core';
 import { _INTERNAL_flushLogsBuffer, applySdkMetadata, logger, SDK_VERSION, ServerRuntimeClient } from '@sentry/core';
-import { getTraceContextForScope } from '@sentry/opentelemetry';
+import {
+  enhanceDscWithOpenTelemetryRootSpanName,
+  getTraceContextForScope,
+  setupEventContextTrace,
+} from '@sentry/opentelemetry';
 import { isMainThread, threadId } from 'worker_threads';
 import { DEBUG_BUILD } from '../debug-build';
 import type { NodeClientOptions } from '../types';
+import { isCjs } from '../utils/commonjs';
+import { envToBool } from '../utils/envToBool';
+import { getSentryRelease } from './api';
 
 const DEFAULT_CLIENT_REPORT_FLUSH_INTERVAL_MS = 60_000; // 60s was chosen arbitrarily
 
@@ -21,15 +28,9 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
   private _logOnExitFlushListener: (() => void) | undefined;
 
   public constructor(options: NodeClientOptions) {
-    const serverName = options.serverName || global.process.env.SENTRY_NAME || os.hostname();
-    const clientOptions: ServerRuntimeClientOptions = {
-      ...options,
-      platform: 'node',
-      runtime: { name: 'node', version: global.process.version },
-      serverName,
-    };
-
-    if (options.openTelemetryInstrumentations) {
+    const clientOptions = applyDefaultOptions(options);
+
+    if (clientOptions.openTelemetryInstrumentations) {
       registerInstrumentations({
         instrumentations: options.openTelemetryInstrumentations,
       });
@@ -40,25 +41,31 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
     logger.log(
       `Initializing Sentry: process: ${process.pid}, thread: ${isMainThread ? 'main' : `worker-${threadId}`}.`,
     );
+    logger.log(`Running in ${isCjs() ? 'CommonJS' : 'ESM'} mode.`);
 
     super(clientOptions);
 
+    this.startClientReportTracking();
+
     if (this.getOptions()._experiments?.enableLogs) {
       this._logOnExitFlushListener = () => {
         _INTERNAL_flushLogsBuffer(this);
       };
 
-      if (serverName) {
+      if (clientOptions.serverName) {
         this.on('beforeCaptureLog', log => {
           log.attributes = {
             ...log.attributes,
-            'server.address': serverName,
+            'server.address': clientOptions.serverName,
           };
         });
       }
 
       process.on('beforeExit', this._logOnExitFlushListener);
     }
+
+    enhanceDscWithOpenTelemetryRootSpanName(this);
+    setupEventContextTrace(this);
   }
 
   /** Get the OTEL tracer. */
@@ -154,3 +161,42 @@ export class NodeClient extends ServerRuntimeClient<NodeClientOptions> {
     return getTraceContextForScope(this, scope);
   }
 }
+
+function applyDefaultOptions<T extends Partial<NodeClientOptions>>(options: T): T {
+  const release = options.release ?? getSentryRelease();
+  const spotlight =
+    options.spotlight ?? envToBool(process.env.SENTRY_SPOTLIGHT, { strict: true }) ?? process.env.SENTRY_SPOTLIGHT;
+  const tracesSampleRate = getTracesSampleRate(options.tracesSampleRate);
+  const serverName = options.serverName || global.process.env.SENTRY_NAME || os.hostname();
+
+  return {
+    platform: 'node',
+    runtime: { name: 'node', version: global.process.version },
+    serverName,
+    ...options,
+    dsn: options.dsn ?? process.env.SENTRY_DSN,
+    environment: options.environment ?? process.env.SENTRY_ENVIRONMENT,
+    sendClientReports: options.sendClientReports ?? true,
+    release,
+    tracesSampleRate,
+    spotlight,
+    debug: envToBool(options.debug ?? process.env.SENTRY_DEBUG),
+  };
+}
+
+/**
+ * Tries to get a `tracesSampleRate`, possibly extracted from the environment variables.
+ */
+export function getTracesSampleRate(tracesSampleRate: NodeClientOptions['tracesSampleRate']): number | undefined {
+  if (tracesSampleRate !== undefined) {
+    return tracesSampleRate;
+  }
+
+  const sampleRateFromEnv = process.env.SENTRY_TRACES_SAMPLE_RATE;
+  if (!sampleRateFromEnv) {
+    return undefined;
+  }
+
+  const parsed = parseFloat(sampleRateFromEnv);
+  return isFinite(parsed) ? parsed : undefined;
+}