ref(logger): read SENTRY_LOG_LEVEL lazily, not at module load time

Follow the same pattern as getSentryUrl() in oauth.ts — env vars are
read at call time so tests can set them after import.

- Replace getInitialLogLevel() (private, called at module load) with
  getEnvLogLevel() (exported, called lazily by bin.ts)
- Logger always starts at DEFAULT_LOG_LEVEL (info=3); bin.ts applies
  env var first, then CLI flags override
- Add getEnvLogLevel tests covering set/unset/empty env var paths
- logger.ts now at 100% patch coverage

Author: BYK

src/bin.ts

@@ -5,7 +5,11 @@ import { buildContext } from "./context.js";
 import { AuthError, formatError, getExitCode } from "./lib/errors.js";
 import { error } from "./lib/formatters/colors.js";
 import { runInteractiveLogin } from "./lib/interactive-login.js";
-import { extractLogLevelFromArgs, setLogLevel } from "./lib/logger.js";
+import {
+  extractLogLevelFromArgs,
+  getEnvLogLevel,
+  setLogLevel,
+} from "./lib/logger.js";
 import { withTelemetry } from "./lib/telemetry.js";
 import { startCleanupOldBinary } from "./lib/upgrade.js";
 import {
@@ -90,9 +94,17 @@ async function main(): Promise<void> {
 
   const args = process.argv.slice(2);
 
+  // Apply SENTRY_LOG_LEVEL env var first (lazy read, not at module load time).
+  // CLI flags below override this if present.
+  const envLogLevel = getEnvLogLevel();
+  if (envLogLevel !== null) {
+    setLogLevel(envLogLevel);
+  }
+
   // Extract global log-level flags before Stricli parses args.
   // --log-level is consumed (removed); --verbose is read but left in place
   // because some commands (e.g., `api`) define their own --verbose flag.
+  // CLI flags take priority over SENTRY_LOG_LEVEL env var.
   const logLevel = extractLogLevelFromArgs(args);
   if (logLevel !== null) {
     setLogLevel(logLevel);

src/lib/logger.ts

@@ -103,16 +103,19 @@ export function parseLogLevel(name: string): number {
 }
 
 /**
- * Read the initial log level from the `SENTRY_LOG_LEVEL` environment variable.
+ * Read the log level from `SENTRY_LOG_LEVEL`, called lazily by {@link setLogLevel}.
  *
- * @returns consola numeric level (defaults to 3 / info)
+ * Following the same pattern as `getSentryUrl()` in oauth.ts — env vars are read
+ * at call time (not module load time) so tests can set them after import.
+ *
+ * @returns consola numeric level, or null if not set
  */
-function getInitialLogLevel(): number {
+export function getEnvLogLevel(): number | null {
   const envLevel = process.env[LOG_LEVEL_ENV_VAR];
   if (envLevel) {
     return parseLogLevel(envLevel);
   }
-  return DEFAULT_LOG_LEVEL;
+  return null;
 }
 
 /**
@@ -124,9 +127,13 @@ function getInitialLogLevel(): number {
  *
  * The Sentry reporter is added lazily via {@link attachSentryReporter} after
  * Sentry.init() completes, since the reporter needs an active Sentry client.
+ *
+ * The initial level defaults to info (3). `SENTRY_LOG_LEVEL` is applied lazily
+ * by bin.ts calling `setLogLevel(getEnvLogLevel())` — not at module load time —
+ * so tests can override the env var after import.
  */
 export const logger = createConsola({
-  level: getInitialLogLevel(),
+  level: DEFAULT_LOG_LEVEL,
   // stderr is the correct stream for diagnostic/log output in CLIs —
   // stdout is reserved for command output (data, JSON, tables).
   stderr: process.stderr,

test/lib/logger.test.ts

@@ -1,14 +1,15 @@
 /**
  * Unit tests for the logger module.
  *
- * Tests parseLogLevel, extractLogLevelFromArgs, setLogLevel,
+ * Tests parseLogLevel, getEnvLogLevel, extractLogLevelFromArgs, setLogLevel,
  * attachSentryReporter, and the logger instance configuration.
  */
 
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   attachSentryReporter,
   extractLogLevelFromArgs,
+  getEnvLogLevel,
   LOG_LEVEL_ENV_VAR,
   LOG_LEVEL_NAMES,
   logger,
@@ -73,6 +74,44 @@ describe("LOG_LEVEL_ENV_VAR", () => {
   });
 });
 
+describe("getEnvLogLevel", () => {
+  let savedEnv: string | undefined;
+
+  beforeEach(() => {
+    savedEnv = process.env[LOG_LEVEL_ENV_VAR];
+  });
+
+  afterEach(() => {
+    if (savedEnv === undefined) {
+      delete process.env[LOG_LEVEL_ENV_VAR];
+    } else {
+      process.env[LOG_LEVEL_ENV_VAR] = savedEnv;
+    }
+  });
+
+  test("returns null when env var is not set", () => {
+    delete process.env[LOG_LEVEL_ENV_VAR];
+    expect(getEnvLogLevel()).toBeNull();
+  });
+
+  test("returns parsed level when env var is set", () => {
+    process.env[LOG_LEVEL_ENV_VAR] = "debug";
+    expect(getEnvLogLevel()).toBe(4);
+  });
+
+  test("returns parsed level for each valid name", () => {
+    for (const [idx, name] of LOG_LEVEL_NAMES.entries()) {
+      process.env[LOG_LEVEL_ENV_VAR] = name;
+      expect(getEnvLogLevel()).toBe(idx);
+    }
+  });
+
+  test("returns null for empty string", () => {
+    process.env[LOG_LEVEL_ENV_VAR] = "";
+    expect(getEnvLogLevel()).toBeNull();
+  });
+});
+
 describe("setLogLevel", () => {
   let originalLevel: number;
 
@@ -209,10 +248,8 @@ describe("logger instance", () => {
   });
 
   test("default level is info (3)", () => {
-    // Unless SENTRY_LOG_LEVEL was set in the environment
-    if (!process.env.SENTRY_LOG_LEVEL) {
-      expect(logger.level).toBe(3);
-    }
+    // Logger always starts at info (3) — env var is applied lazily by bin.ts
+    expect(logger.level).toBe(3);
   });
 });