pkg/telemetry/telemetry_test.go (2)

19-20: Remove hardcoded token constant.

Keep secrets out of VCS; rely on env as shown above.

-const (
-	TestPosthogIntegrationToken = "phc_7s7MrHWxPR2if1DHHDrKBRgx7SvlaoSM59fIiQueexS"
-)
+// Integration token is supplied via POSTHOG_TEST_TOKEN when tests are explicitly enabled.

---

26-31: Use deterministic randomness or seed.

Non-deterministic rand can complicate reproducing failures; either seed test-local RNG or use fixed values.

pkg/telemetry/telemetry.go (3)

72-77: Trap Close() errors at debug.

Silent ignore can mask flush failures; log them at debug without user impact.

-	defer func() {
-		// Ensure client close doesn't panic or output errors
-		if client != nil {
-			client.Close()
-		}
-	}()
+	defer func() {
+		// Ensure client close doesn't panic or output errors.
+		if client != nil {
+			if cerr := client.Close(); cerr != nil {
+				log.Debug("PostHog client close failed", "error", cerr)
+			}
+		}
+	}()

---

8-20: Deduplicate doc comments.

Two identical blocks above TelemetryClientProvider. Keep one concise godoc.

-// TelemetryClientProvider is a function type that creates a PostHog client
-// given a token and configuration. This allows for dependency injection
-// and easier testing by providing mock implementations.
-// TelemetryClientProvider is a function type that creates a PostHog client
-// given a token and configuration. The configuration is passed by pointer to
-// avoid copying large structs and to allow tests to modify it.
+// TelemetryClientProvider creates a PostHog client given a token and configuration.
+// The configuration is passed by pointer to avoid copying and to allow tests to modify it.

---

48-53: Godot: end comments with periods.

Several comment lines end without periods; golangci-lint (godot) will complain.

Also applies to: 79-81, 91-93

pkg/telemetry/posthog_logger_test.go (2)

84-103: Restore original log level in SilentLogger test.

Avoid cross-test level bleed.

 func TestSilentLogger(t *testing.T) {
-	defer log.SetOutput(io.Discard) // Reset output after test
+	defer log.SetOutput(io.Discard) // Reset output after test
+	orig := log.GetLevel()
+	defer log.SetLevel(orig)

---

105-127: Same: restore level in DiscardLogger test.

 func TestDiscardLogger(t *testing.T) {
-	defer log.SetOutput(io.Discard) // Reset output after test
+	defer log.SetOutput(io.Discard) // Reset output after test
+	orig := log.GetLevel()
+	defer log.SetLevel(orig)

pkg/telemetry/posthog_logger.go (1)

25-30: Godot: add periods to inline comments.

Several comment lines are missing trailing periods; fix to satisfy golangci-lint godot.

-	// Convert printf-style to structured logging
+	// Convert printf-style to structured logging.
-	// Convert printf-style to structured logging at debug level
-	// to avoid cluttering user output with telemetry info
+	// Convert printf-style to structured logging at debug level.
+	// To avoid cluttering user output with telemetry info.
-	// Convert printf-style to structured logging
+	// Convert printf-style to structured logging.
-	// Only log PostHog errors at debug level to avoid polluting user output.
-	// Telemetry failures should not impact the user experience.
+	// Only log PostHog errors at debug level to avoid polluting user output.
+	// Telemetry failures should not impact the user experience.

Also applies to: 36-40, 44-47, 52-56

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*_test.go : Every new feature must include comprehensive unit tests

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*_test.go : Test both happy paths and error conditions

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*_test.go : Consider using testify/mock for creating mock implementations

Learnt from: CR
PR: cloudposse/atmos#0
File: CLAUDE.md:0-0
Timestamp: 2025-09-07T15:13:17.831Z
Learning: Applies to **/*_test.go : Use table-driven unit tests and mock interfaces for external dependencies; target >80% coverage.

pkg/schema/schema.go (1)

253-254: Make logging tag consistent with other telemetry fields.

To avoid emitting logging: false on marshal and to match neighboring tags, add omitempty.

-   Logging  bool   `yaml:"logging" json:"logging" mapstructure:"logging"`
+   Logging  bool   `yaml:"logging,omitempty" json:"logging,omitempty" mapstructure:"logging"`

pkg/telemetry/telemetry_logger_selection_test.go (2)

16-40: Deduplicate the two subtests to satisfy dupl lint and reduce noise.

Refactor into a small helper; keep assertions unchanged.

 func TestTelemetryLoggerSelectionBasedOnFlag(t *testing.T) {
-	// Test with logging enabled - should use PosthogLogger
-	t.Run("LoggingEnabled", func(t *testing.T) {
-		ctrl := gomock.NewController(t)
-		defer ctrl.Finish()
-
-		// Create a custom mock provider to inspect the config
-		var capturedConfig *posthog.Config
-		mockProvider := func(token string, config *posthog.Config) (posthog.Client, error) {
-			capturedConfig = config
-			mockClient := mock_telemetry.NewMockClient(ctrl)
-			mockClient.EXPECT().Enqueue(gomock.Any()).Return(nil).Times(1)
-			mockClient.EXPECT().Close().Return(nil).Times(1)
-			return mockClient, nil
-		}
-
-		// Create telemetry with logging enabled
-		telemetry := NewTelemetry(true, "test-token", "https://test.com", "test-id", true, mockProvider)
-		success := telemetry.Capture("test", map[string]interface{}{})
-
-		assert.True(t, success)
-		assert.NotNil(t, capturedConfig)
-		assert.NotNil(t, capturedConfig.Logger)
-		// Verify it's a PosthogLogger by checking type
-		_, isPosthogLogger := capturedConfig.Logger.(*PosthogLogger)
-		assert.True(t, isPosthogLogger, "Should use PosthogLogger when logging is enabled")
-	})
-
-	// Test with logging disabled - should use SilentLogger
-	t.Run("LoggingDisabled", func(t *testing.T) {
-		ctrl := gomock.NewController(t)
-		defer ctrl.Finish()
-
-		// Create a custom mock provider to inspect the config
-		var capturedConfig *posthog.Config
-		mockProvider := func(token string, config *posthog.Config) (posthog.Client, error) {
-			capturedConfig = config
-			mockClient := mock_telemetry.NewMockClient(ctrl)
-			mockClient.EXPECT().Enqueue(gomock.Any()).Return(nil).Times(1)
-			mockClient.EXPECT().Close().Return(nil).Times(1)
-			return mockClient, nil
-		}
-
-		// Create telemetry with logging disabled
-		telemetry := NewTelemetry(true, "test-token", "https://test.com", "test-id", false, mockProvider)
-		success := telemetry.Capture("test", map[string]interface{}{})
-
-		assert.True(t, success)
-		assert.NotNil(t, capturedConfig)
-		assert.NotNil(t, capturedConfig.Logger)
-		// Verify it's a SilentLogger by checking type
-		_, isSilentLogger := capturedConfig.Logger.(*SilentLogger)
-		assert.True(t, isSilentLogger, "Should use SilentLogger when logging is disabled")
-	})
+	run := func(name string, logging bool) {
+		t.Run(name, func(t *testing.T) {
+			t.Helper()
+			ctrl := gomock.NewController(t)
+			defer ctrl.Finish()
+			var capturedConfig *posthog.Config
+			mockProvider := func(token string, config *posthog.Config) (posthog.Client, error) {
+				capturedConfig = config
+				mockClient := mock_telemetry.NewMockClient(ctrl)
+				mockClient.EXPECT().Enqueue(gomock.Any()).Return(nil).Times(1)
+				mockClient.EXPECT().Close().Return(nil).Times(1)
+				return mockClient, nil
+			}
+			telemetry := NewTelemetry(true, "test-token", "https://test.com", "test-id", logging, mockProvider)
+			success := telemetry.Capture("test", map[string]interface{}{})
+			assert.True(t, success)
+			assert.NotNil(t, capturedConfig)
+			assert.NotNil(t, capturedConfig.Logger)
+			if logging {
+				_, isPosthogLogger := capturedConfig.Logger.(*PosthogLogger)
+				assert.True(t, isPosthogLogger, "Should use PosthogLogger when logging is enabled.")
+			} else {
+				_, isSilentLogger := capturedConfig.Logger.(*SilentLogger)
+				assert.True(t, isSilentLogger, "Should use SilentLogger when logging is disabled.")
+			}
+		})
+	}
+	run("LoggingEnabled", true)
+	run("LoggingDisabled", false)
 }

Also applies to: 43-67

---

12-14: Fix comment periods to satisfy godot.

End sentences with periods.

-// TestTelemetryLoggerSelectionBasedOnFlag tests that the correct logger is selected
-// based on the logging flag during client creation.
+// TestTelemetryLoggerSelectionBasedOnFlag tests that the correct logger is selected.
+// It is based on the logging flag during client creation.
-// Verify it's a PosthogLogger by checking type
+// Verify it's a PosthogLogger by checking type.
-// Verify it's a SilentLogger by checking type
+// Verify it's a SilentLogger by checking type.
-// TestTelemetryConstructorWithLogging tests that the telemetry constructor correctly
-// handles the logging parameter.
+// TestTelemetryConstructorWithLogging tests that the telemetry constructor correctly.
+// It handles the logging parameter.

Also applies to: 38-38, 65-65, 70-72

pkg/telemetry/telemetry.go (2)

8-14: Remove duplicate doc comments.

Two identical comment blocks for both the type and provider are repeated back‑to‑back.

-// TelemetryClientProvider is a function type that creates a PostHog client
-// given a token and configuration. This allows for dependency injection
-// and easier testing by providing mock implementations.
-// TelemetryClientProvider is a function type that creates a PostHog client
-// given a token and configuration. The configuration is passed by pointer to
-// avoid copying large structs and to allow tests to modify it.
+// TelemetryClientProvider is a function type that creates a PostHog client given a token and configuration.
+// The configuration is passed by pointer to avoid copying and to allow tests to inspect/modify it.
 type TelemetryClientProvider func(string, *posthog.Config) (posthog.Client, error)
 
-// PosthogClientProvider is the default implementation of TelemetryClientProvider
-// that creates a real PostHog client using the provided token and configuration.
-// PosthogClientProvider is the default implementation of TelemetryClientProvider
-// that creates a real PostHog client using the provided token and configuration.
+// PosthogClientProvider is the default implementation of TelemetryClientProvider that creates a real PostHog client.
 func PosthogClientProvider(token string, config *posthog.Config) (posthog.Client, error) {

Also applies to: 16-22

---

63-71: Tighten comments for godot and log close errors at debug.

End sentences with periods and surface Close errors at debug without leaking to users.

-	// Create PostHog client using the provided client provider with custom logger
-	// This ensures PostHog errors don't leak to stdout/stderr
-	// Select logger based on logging configuration
+	// Create PostHog client using the provided client provider with a custom logger.
+	// This ensures PostHog errors don't leak to stdout/stderr.
+	// Select logger based on logging configuration.
 	var logger posthog.Logger
 	if t.logging {
-		logger = NewPosthogLogger() // Use our custom logger adapter that routes to Atmos logging
+		logger = NewPosthogLogger() // Use our custom logger adapter that routes to Atmos logging.
 	} else {
-		logger = NewSilentLogger() // Completely suppress PostHog internal logging
+		logger = NewSilentLogger() // Completely suppress PostHog internal logging.
 	}
@@
-	defer func() {
-		// Ensure client close doesn't panic or output errors
+	defer func() {
+		// Ensure client close doesn't panic or output errors.
 		if client != nil {
-			client.Close()
+			if cerr := client.Close(); cerr != nil {
+				log.Debug("Could not close PostHog client", "error", cerr)
+			}
 		}
 	}()
@@
-		// Log at debug level to avoid polluting user output with telemetry errors
+		// Log at debug level to avoid polluting user output with telemetry errors.
 		log.Debug("Could not enqueue event", "error", err)
 		return false
 	}
-	// Note: Event is only sent when client.Close() is called in the deferred function
-	log.Debug("Telemetry event enqueued")
+	// Note: Event is only sent when client.Close() is called in the deferred function.
+	log.Debug("Telemetry event enqueued")

Also applies to: 82-87, 97-103

pkg/telemetry/utils_test.go (2)

537-563: Consolidate logging config tests + restore env var safely.

These three tests are near-identical and can be table‑driven. Also, preserve/restore ATMOS_TELEMETRY_LOGGING to avoid cross‑test leakage.

Apply this diff to replace the three tests with one table‑driven test that restores the original env var:

-// TestGetTelemetryFromConfigWithLoggingEnabled tests that logging can be enabled via environment variable.
-func TestGetTelemetryFromConfigWithLoggingEnabled(t *testing.T) {
-  currentEnvVars := PreserveCIEnvVars()
-  defer RestoreCIEnvVars(currentEnvVars)
-
-  ctrl := gomock.NewController(t)
-  mockClientProvider := mock_telemetry.NewMockTelemetryClientProviderMock(ctrl)
-  mockClient := mock_telemetry.NewMockClient(ctrl)
-
-  // Expect no client creation since we're just testing config loading.
-  mockClientProvider.EXPECT().NewMockClient(gomock.Any(), gomock.Any()).Return(mockClient, nil).Times(0)
-  mockClient.EXPECT().Enqueue(gomock.Any()).Return(nil).Times(0)
-  mockClient.EXPECT().Close().Return(nil).Times(0)
-
-  // Enable logging via environment variable.
-  os.Setenv("ATMOS_TELEMETRY_LOGGING", "true")
-  defer os.Unsetenv("ATMOS_TELEMETRY_LOGGING")
-
-  // Get telemetry configuration.
-  telemetry := getTelemetryFromConfig(mockClientProvider.NewMockClient)
-
-  // Verify logging is enabled.
-  assert.NotNil(t, telemetry)
-  assert.True(t, telemetry.logging, "Logging should be enabled when ATMOS_TELEMETRY_LOGGING=true")
-}
-
-// TestGetTelemetryFromConfigWithLoggingDisabled tests that logging can be disabled via environment variable.
-func TestGetTelemetryFromConfigWithLoggingDisabled(t *testing.T) {
-  currentEnvVars := PreserveCIEnvVars()
-  defer RestoreCIEnvVars(currentEnvVars)
-
-  ctrl := gomock.NewController(t)
-  mockClientProvider := mock_telemetry.NewMockTelemetryClientProviderMock(ctrl)
-  mockClient := mock_telemetry.NewMockClient(ctrl)
-
-  // Expect no client creation since we're just testing config loading.
-  mockClientProvider.EXPECT().NewMockClient(gomock.Any(), gomock.Any()).Return(mockClient, nil).Times(0)
-  mockClient.EXPECT().Enqueue(gomock.Any()).Return(nil).Times(0)
-  mockClient.EXPECT().Close().Return(nil).Times(0)
-
-  // Explicitly disable logging via environment variable.
-  os.Setenv("ATMOS_TELEMETRY_LOGGING", "false")
-  defer os.Unsetenv("ATMOS_TELEMETRY_LOGGING")
-
-  // Get telemetry configuration.
-  telemetry := getTelemetryFromConfig(mockClientProvider.NewMockClient)
-
-  // Verify logging is disabled.
-  assert.NotNil(t, telemetry)
-  assert.False(t, telemetry.logging, "Logging should be disabled when ATMOS_TELEMETRY_LOGGING=false")
-}
-
-// TestGetTelemetryFromConfigWithLoggingDefault tests the default logging configuration.
-func TestGetTelemetryFromConfigWithLoggingDefault(t *testing.T) {
-  currentEnvVars := PreserveCIEnvVars()
-  defer RestoreCIEnvVars(currentEnvVars)
-
-  ctrl := gomock.NewController(t)
-  mockClientProvider := mock_telemetry.NewMockTelemetryClientProviderMock(ctrl)
-  mockClient := mock_telemetry.NewMockClient(ctrl)
-
-  // Expect no client creation since we're just testing config loading.
-  mockClientProvider.EXPECT().NewMockClient(gomock.Any(), gomock.Any()).Return(mockClient, nil).Times(0)
-  mockClient.EXPECT().Enqueue(gomock.Any()).Return(nil).Times(0)
-  mockClient.EXPECT().Close().Return(nil).Times(0)
-
-  // Ensure ATMOS_TELEMETRY_LOGGING is not set.
-  os.Unsetenv("ATMOS_TELEMETRY_LOGGING")
-
-  // Get telemetry configuration.
-  telemetry := getTelemetryFromConfig(mockClientProvider.NewMockClient)
-
-  // Verify logging defaults to false (as configured in atmos.yaml).
-  assert.NotNil(t, telemetry)
-  assert.False(t, telemetry.logging, "Logging should default to false")
-}
+func TestGetTelemetryFromConfigLoggingVariants(t *testing.T) {
+  currentEnvVars := PreserveCIEnvVars()
+  defer RestoreCIEnvVars(currentEnvVars)
+
+  ctrl := gomock.NewController(t)
+  defer ctrl.Finish()
+
+  mockClientProvider := mock_telemetry.NewMockTelemetryClientProviderMock(ctrl)
+  mockClient := mock_telemetry.NewMockClient(ctrl)
+
+  // No client creation; config‑only.
+  mockClientProvider.EXPECT().NewMockClient(gomock.Any(), gomock.Any()).Return(mockClient, nil).Times(0)
+  mockClient.EXPECT().Enqueue(gomock.Any()).Return(nil).Times(0)
+  mockClient.EXPECT().Close().Return(nil).Times(0)
+
+  cases := []struct {
+    name   string
+    hasEnv bool
+    envVal string
+    want   bool
+  }{
+    {"enabled", true, "true", true},
+    {"disabled", true, "false", false},
+    {"default", false, "", false}, // atmos.yaml default is false.
+  }
+
+  for _, tc := range cases {
+    t.Run(tc.name, func(t *testing.T) {
+      const key = "ATMOS_TELEMETRY_LOGGING"
+      old, had := os.LookupEnv(key)
+      if tc.hasEnv {
+        os.Setenv(key, tc.envVal)
+      } else {
+        os.Unsetenv(key)
+      }
+      t.Cleanup(func() {
+        if had {
+          os.Setenv(key, old)
+        } else {
+          os.Unsetenv(key)
+        }
+      })
+
+      telemetry := getTelemetryFromConfig(mockClientProvider.NewMockClient)
+      assert.NotNil(t, telemetry)
+      assert.Equal(t, tc.want, telemetry.logging, "unexpected logging value for case %q", tc.name)
+    })
+  }
+}

Also applies to: 565-589, 590-614

---

543-546: Finish gomock controllers.

Add deferred ctrl.Finish() to assert expectations promptly.

 ctrl := gomock.NewController(t)
+defer ctrl.Finish()

Also applies to: 569-572, 595-598, 620-623, 642-645

pkg/telemetry/telemetry_test.go (2)

333-339: Gate the networked integration test.

This creates a real client and will hit the network. Gate behind an env flag or testing.Short to avoid flaky CI.

Add at the top of the test:

if testing.Short() || os.Getenv("RUN_POSTHOG_INTEGRATION") == "" {
  t.Skipf("Skipping PostHog integration test; set RUN_POSTHOG_INTEGRATION=1 to enable.")
}

---

399-406: Also gate the wrong-endpoint integration test.

Same concern; guard to keep CI green when offline.

Use the same guard as suggested for the other integration test.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: osterman
PR: cloudposse/atmos#1433
File: cmd/theme_list.go:33-36
Timestamp: 2025-08-29T20:57:35.423Z
Learning: In the Atmos codebase, avoid using viper.SetEnvPrefix("ATMOS") with viper.AutomaticEnv() because canonical environment variable names are not exclusive to Atmos and could cause conflicts. Instead, use selective environment variable binding through the setEnv function in pkg/config/load.go with bindEnv(v, "config.key", "ENV_VAR_NAME") for specific environment variables.

Learnt from: CR
PR: cloudposse/atmos#0
File: CLAUDE.md:0-0
Timestamp: 2025-09-07T15:13:17.831Z
Learning: Applies to **/*.go : Always bind environment variables with viper.BindEnv() and provide ATMOS_ alternatives for each external var.

Learnt from: samtholiya
PR: cloudposse/atmos#1147
File: pkg/config/load.go:0-0
Timestamp: 2025-04-10T20:48:22.687Z
Learning: In the `bindEnv` function in `pkg/config/load.go`, panic is used deliberately instead of returning errors because errors from `BindEnv` would only occur due to developer mistakes. Using panic helps with early detection of these developer errors during initialization.

Learnt from: osterman
PR: cloudposse/atmos#1202
File: pkg/utils/yaml_func_exec.go:104-104
Timestamp: 2025-04-23T15:02:50.246Z
Learning: In the Atmos codebase, direct calls to `os.Getenv` should be avoided. Instead, use `viper.BindEnv` for environment variable access. This provides a consistent approach to configuration management across the codebase.

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*.go : Use Viper for managing configuration, environment variables, and flags

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*.go : Use Viper for configuration management

Learnt from: CR
PR: cloudposse/atmos#0
File: CLAUDE.md:0-0
Timestamp: 2025-09-07T15:13:17.831Z
Learning: Applies to **/*.go : For non-standard execution paths, capture telemetry with telemetry.CaptureCmd or telemetry.CaptureCmdString and never capture user data.

tests/snapshots/TestCLICommands_Valid_log_file_in_env_should_be_priortized_over_config.stdout.golden (2)

6-7: Duplicate ENV log lines.

The repeated “Found ENV variable ATMOS_VERSION_CHECK_ENABLED=false” suggests init is running twice or logging isn’t deduped. Worth tightening to reduce snapshot brittleness.

---

1-1: Typo in filename: “priortized” → “prioritized”.

Recommend renaming test/snapshot to avoid future search misses and minor papercuts.

tests/snapshots/TestCLICommands_Valid_log_level_in_flag_should_be_priortized_over_env_and_config.stderr.golden (2)

2-4: Reduce duplicated ENV logs (non-blocking)

Same line logged thrice adds noise to snapshots; consider consolidating detection logs or logging once per variable.

If helpful, I can draft a tiny helper that memoizes ENV discovery logs to avoid repeats.

---

1-1: Fix typo: "priortized" → "prioritized" in test case names

• tests/test-cases/log-level-validation.yaml:103 — "Valid log level in env should be priortized over config"
• tests/test-cases/log-level-validation.yaml:122 — "Valid log level in flag should be priortized over env and config"
• tests/test-cases/log-level-validation.yaml:143 — "Valid log file in env should be priortized over config"
• tests/test-cases/log-level-validation.yaml:164 — "Valid log file in flag should be priortized over env and config"

Rename "priortized" → "prioritized" in those test names and regenerate snapshots for consistency.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

tests/cli_test.go (2)

348-352: Precompile regex at package scope; optional pattern hardening.

Minor perf/readability win: compile once and reuse. Optionally add word boundaries and a loose length to reduce accidental overmatches.

Apply this diff here:

-	posthogTokenRegex := regexp.MustCompile(`phc_[a-zA-Z0-9_]+`)
-	result = posthogTokenRegex.ReplaceAllString(result, "phc_TEST_TOKEN_PLACEHOLDER")
+	result = rePosthogToken.ReplaceAllString(result, "phc_TEST_TOKEN_PLACEHOLDER")

And add near the top of the file (package scope):

var rePosthogToken = regexp.MustCompile(`\bphc_[A-Za-z0-9_]{10,64}\b`)

If you prefer to keep the original character class, retain it but still precompile.

---

348-352: Masking implemented; no PostHog tokens found in snapshots.
Scan of tests/snapshots returned no phc_ tokens besides phc_TEST_TOKEN_PLACEHOLDER.

• Optional: centralize this masking in sanitizeOutput for consistency.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.