feat(dsn): add verbose debug logging for DSN discovery flow

Surfaces DSN detection details when running any command with --verbose,
following the existing log.debug() + withTag() pattern. Logs project root
detection, cache hits/misses, scan stats, each found DSN with source,
and org/project resolution results.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: betegon

src/lib/dsn/code-scanner.ts

@@ -686,6 +686,10 @@ function scanDirectory(
 
       const { files, dirMtimes } = collectResult;
 
+      log.debug(
+        `Code scan: collected ${files.length} files from ${Object.keys(dirMtimes).length} directories`
+      );
+
       span.setAttribute("dsn.files_collected", files.length);
 
       if (files.length === 0) {
@@ -699,6 +703,10 @@ function scanDirectory(
         stopOnFirst
       );
 
+      log.debug(
+        `Code scan: scanned ${filesScanned} files, found ${results.size} DSN(s)`
+      );
+
       span.setAttributes({
         "dsn.files_scanned": filesScanned,
         "dsn.dsns_found": results.size,

src/lib/dsn/detector.ts

@@ -35,6 +35,7 @@ import {
   detectFromEnvFiles,
   extractDsnFromEnvContent,
 } from "./env-file.js";
+import { logger } from "../logger.js";
 import { createDetectedDsn, createDsnFingerprint, parseDsn } from "./parser.js";
 import { findProjectRoot } from "./project-root.js";
 import type {
@@ -44,6 +45,8 @@ import type {
   DsnSource,
 } from "./types.js";
 
+const log = logger.withTag("dsn-detect");
+
 /**
  * Detect DSN with project root detection and caching support.
  *
@@ -86,6 +89,7 @@ export async function detectDsn(cwd: string): Promise<DetectedDsn | null> {
       }
 
       // Cache hit! Return with resolved info if available
+      log.debug(`DSN cache hit for ${projectRoot}`);
       return {
         ...verified,
         resolved: cached.resolved,
@@ -98,6 +102,9 @@ export async function detectDsn(cwd: string): Promise<DetectedDsn | null> {
   const detected = await fullScanFirst(projectRoot);
 
   if (detected) {
+    log.debug(
+      `DSN detected: ${detected.raw} from ${getDsnSourceDescription(detected)}`
+    );
     // Cache for next time (without resolved info yet)
     setCachedDsn(projectRoot, {
       dsn: detected.raw,
@@ -106,6 +113,8 @@ export async function detectDsn(cwd: string): Promise<DetectedDsn | null> {
       source: detected.source,
       sourcePath: detected.sourcePath,
     });
+  } else {
+    log.debug(`No DSN found after full scan of ${projectRoot}`);
   }
 
   return detected;
@@ -144,11 +153,16 @@ export async function detectAllDsns(cwd: string): Promise<DsnDetectionResult> {
     });
   }
 
+  log.debug(`DSN detection starting from project root: ${projectRoot}`);
+
   // 2. Try cached detection result
   const cachedDetection = await getCachedDetection(projectRoot);
 
   if (cachedDetection) {
     // Cache hit! Return cached result
+    log.debug(
+      `DSN detection cache hit: ${cachedDetection.allDsns.length} DSN(s) cached`
+    );
     return {
       primary: cachedDetection.allDsns[0] ?? null,
       all: cachedDetection.allDsns,
@@ -182,6 +196,9 @@ export async function detectAllDsns(cwd: string): Promise<DsnDetectionResult> {
   }
   Object.assign(allSourceMtimes, codeMtimes);
   Object.assign(allDirMtimes, codeDirMtimes);
+  if (codeDsns.length > 0) {
+    log.debug(`Found ${codeDsns.length} DSN(s) in source code`);
+  }
 
   // 3b. Check all .env files from project root (includes monorepo packages/apps)
   const { dsns: envFileDsns, sourceMtimes: envMtimes } =
@@ -190,11 +207,15 @@ export async function detectAllDsns(cwd: string): Promise<DsnDetectionResult> {
     addDsn(dsn);
   }
   Object.assign(allSourceMtimes, envMtimes);
+  if (envFileDsns.length > 0) {
+    log.debug(`Found ${envFileDsns.length} DSN(s) in .env files`);
+  }
 
   // 3c. Check env var (lowest priority) - no mtime for env vars
   const envDsn = detectFromEnv();
   if (envDsn) {
     addDsn(envDsn);
+    log.debug("Found DSN in SENTRY_DSN environment variable");
   }
 
   // 4. Compute fingerprint and cache result
@@ -222,6 +243,18 @@ export async function detectAllDsns(cwd: string): Promise<DsnDetectionResult> {
   // Multiple DSNs is valid in monorepos (different packages/apps)
   const hasMultiple = allDsns.length > 1;
 
+  if (allDsns.length > 0) {
+    log.debug(`DSN detection complete: ${allDsns.length} total DSN(s) found`);
+    for (const dsn of allDsns) {
+      const isPrimary = dsn === allDsns[0] ? " [primary]" : "";
+      log.debug(
+        `  ${dsn.raw} — ${getDsnSourceDescription(dsn)}${isPrimary}`
+      );
+    }
+  } else {
+    log.debug("DSN detection complete: no DSNs found");
+  }
+
   return {
     primary: allDsns[0] ?? null,
     all: allDsns,

src/lib/dsn/env-file.ts

@@ -10,12 +10,15 @@
 
 import { opendir } from "node:fs/promises";
 import { join } from "node:path";
+import { logger } from "../logger.js";
 import { withTracingSpan } from "../telemetry.js";
 import { createDetectedDsn } from "./parser.js";
 import { scanSpecificFiles } from "./scanner.js";
 import type { DetectedDsn } from "./types.js";
 import { MONOREPO_ROOTS } from "./types.js";
 
+const log = logger.withTag("dsn-env-file");
+
 /**
  * Result of scanning env files, including mtimes for caching.
  */
@@ -156,6 +159,9 @@ export async function detectFromAllEnvFiles(
         });
       allDsns.push(...rootDsns);
       Object.assign(allMtimes, rootMtimes);
+      if (rootDsns.length > 0) {
+        log.debug(`Found ${rootDsns.length} DSN(s) in root .env files`);
+      }
 
       // 2. Check monorepo package directories
       const {
@@ -165,6 +171,11 @@ export async function detectFromAllEnvFiles(
       } = await detectFromMonorepoEnvFiles(cwd);
       allDsns.push(...monorepoDsns);
       Object.assign(allMtimes, monorepoMtimes);
+      if (packagesScanned > 0) {
+        log.debug(
+          `Scanned ${packagesScanned} monorepo packages, found ${monorepoDsns.length} DSN(s) in package .env files`
+        );
+      }
 
       // Root checks ENV_FILES.length names; each monorepo package also checks ENV_FILES.length
       const filesChecked = ENV_FILES.length * (1 + packagesScanned);

src/lib/dsn/project-root.ts

@@ -16,13 +16,16 @@
 import { opendir, stat } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
+import { logger } from "../logger.js";
 import { anyTrue } from "../promises.js";
 import { withFsSpan, withTracingSpan } from "../telemetry.js";
 import { ENV_FILES, extractDsnFromEnvContent } from "./env-file.js";
 import { handleFileError } from "./fs-utils.js";
 import { createDetectedDsn } from "./parser.js";
 import type { DetectedDsn } from "./types.js";
 
+const log = logger.withTag("dsn-project-root");
+
 /** Why a directory was chosen as project root */
 export type ProjectRootReason =
   | "env_dsn" // Found .env with SENTRY_DSN
@@ -554,6 +557,10 @@ export function findProjectRoot(startDir: string): Promise<ProjectRootResult> {
 
       const result = await walkUpDirectories(resolvedStart, stopBoundary);
 
+      log.debug(
+        `Project root: ${result.projectRoot} (reason: ${result.reason})`
+      );
+
       span.setAttributes({
         "dsn.found": result.foundDsn !== undefined,
         "dsn.reason": result.reason,

src/lib/resolve-target.ts

@@ -926,6 +926,15 @@ async function resolveDetectedDsns(
   // Count DSNs that couldn't be resolved (API errors, permissions, etc.)
   const unresolvedCount = resolvedTargets.filter((t) => t === null).length;
 
+  for (const t of targets) {
+    log.debug(`Resolved: ${t.org}/${t.project} (from DSN)`);
+  }
+  if (unresolvedCount > 0) {
+    log.debug(
+      `DSN resolution: ${unresolvedCount} DSN(s) could not be resolved`
+    );
+  }
+
   if (targets.length === 0) {
     return {
       targets: [],