Extension 'stuck' in Parsing projects state

[Vgrunert]

Expected behavior

The setup should finish properly so that i can choose my target

Actual behavior

The process is stuck in the 'Parsing projects' state.

Steps To Reproduce

dbt --version
Core:

• installed: 1.9.4
• latest: 1.10.15 - Update available!

Your version of dbt-core is out of date!
You can find instructions for upgrading here:
https://docs.getdbt.com/docs/installation

Plugins:

• snowflake: 1.9.2 - Update available!

At least one plugin is out of date with dbt-core.
You can find instructions for upgrading here:
https://docs.getdbt.com/docs/installation

Identifier
innoverio.vscode-dbt-power-user
Version
0.58.13
Published
5 years ago
Last Released
3 weeks ago

Log output/Screenshots

Operating System

Windows

dbt version

1.9.4

dbt Adapter

snowflake

dbt Power User version

0.58.13

Are you willing to submit PR?

• Yes I am willing to submit a PR!

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

✅ Successfully generated implementation plan.

💡 Use @coderabbitai <feedback> to replan

Examples

• Example 1
• Example 2

🔗 Similar Issues

Possible Duplicates

• 1764

Related Issues

• AltimateAI/vscode-dbt-power-user#1764
• AltimateAI/vscode-dbt-power-user#1675
• AltimateAI/vscode-dbt-power-user#1681
• AltimateAI/vscode-dbt-power-user#1603
• AltimateAI/vscode-dbt-power-user#1740

👤 Suggested Assignees

• Alysasa
• CyclopseLegs
• mvfc
• lucy-lee-gustie
• anitalySuper

---

🧪 Issue enrichment is currently in early access.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

[coderabbitai]

Implementation Plan

Approach

The extension becomes stuck indefinitely in "Parsing projects" state during initialization, preventing users from selecting a target. This occurs because the manifest parsing operation has no timeout protection, errors during activation are silently swallowed, and users have no way to cancel or recover from a stalled parsing operation.

Observations

The dbt Power User extension uses an event-driven architecture where DBTProjectContainer orchestrates project initialization, delegates manifest parsing to the @altimateai/dbt-integration library via DBTProject, and emits status events that update the VersionStatusBar. The extension follows patterns of using window.withProgress() for long-running operations with cancellation support (via AbortController + CancellationToken), displaying errors via window.showErrorMessage() with action buttons, and logging diagnostics to dedicated output channels. However, the current activation flow (detectDBT() → initializeDBTProjects() → statusBars.initialize()) silently swallows errors and provides no timeout or cancellation mechanism for manifest parsing.

Assumptions

Assumption 1: Should parsing timeout be configurable or use a fixed default?

Options Considered:

• Fixed timeout of 5 minutes (simple, works for most projects)
• Configurable timeout via workspace settings (flexible but adds complexity)
• No timeout, rely only on user cancellation (insufficient safety net)

Chosen Option: Configurable timeout with sensible default (5 minutes)

Rationale: This provides flexibility for users with large projects while protecting most users from indefinite hangs. This aligns with the extension's existing configuration patterns (e.g., dbt.installDepsOnProjectInitialization) and gives users control without requiring them to understand implementation details.

Assumption 2: How should the timeout wrapper interact with the underlying dbt-integration library?

Options Considered:

• Use Promise.race() to timeout but allow background operation to continue (simple, no library changes needed)
• Investigate if dbt-integration supports AbortSignal for parseManifest() and implement proper cancellation (cleaner but requires library support verification)
• Implement both timeout and cancellation if supported (most robust)

Chosen Option: Promise.race() with timeout wrapper initially

Rationale: This provides immediate protection without requiring changes to or deep investigation of the dbt-integration library API. The wrapper will timeout the Promise even if the underlying operation continues, which is acceptable since it unblocks the UI and allows error recovery. If future investigation reveals the library supports AbortSignal for parseManifest(), it can be added as an enhancement.

Assumption 3: How should errors during initialization be surfaced to users?

Options Considered:

• Show error notification immediately when any initialization step fails (intrusive but immediate feedback)
• Only show error for parsing timeout/failure, not for other initialization steps (focused on the ticket's specific issue)
• Add retry logic without user notification (silent recovery attempt)

Chosen Option: Show error notification with action buttons for parsing failures

Rationale: This follows the existing pattern in walkthroughCommands.ts where errors are shown via window.showErrorMessage() with recovery options like "Retry" and "View Logs". This provides clear feedback without being overly intrusive for initialization steps that may fail gracefully (like detectDBT returning false).

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Plan

Phase 1: Add Timeout Protection and Error Recovery

This phase adds a safety mechanism to prevent indefinite hanging during manifest parsing and provides users with recovery options when parsing fails or times out.

Task 1: Add Configuration Setting for Parse Timeout

Add a new workspace configuration setting to control the parsing timeout duration.

• Add dbt.parseTimeout setting to package.json with default value of 300000ms (5 minutes) and description explaining it controls manifest parsing timeout
• Document the setting with guidance that larger projects may need higher values
• Setting should be type "number" with minimum value of 30000ms (30 seconds)

Task 2: Create Timeout Wrapper Utility

Create a reusable timeout wrapper utility that can be applied to any Promise-based operation.

• Create new utility function in src/utils/ directory (e.g., promiseTimeout.ts) that takes a Promise, timeout duration, and optional error message
• Implement using Promise.race() pattern: race between the original promise and a timeout promise that rejects after specified duration
• Return typed result that indicates success, timeout, or error with appropriate error details
• Include elapsed time tracking for telemetry purposes

Task 3: Apply Timeout Wrapper to Manifest Parsing

Wrap the manifest parsing operation with timeout protection in the DBTProject class.

• Modify parseManifest() method in src/dbt_client/dbtProject.ts to wrap the this.dbtProjectIntegration.parseManifest() call with the timeout utility
• Read timeout value from workspace configuration (dbt.parseTimeout)
• Add try-catch to handle timeout errors specifically (distinguish from other parsing errors)
• Log timeout events to diagnostics output channel with project path and elapsed time
• Emit telemetry event for both successful and timed-out parsing operations

Task 4: Surface Parsing Errors to Users

Modify the extension activation flow to catch and display parsing errors instead of silently swallowing them.

• Update the activation try-catch block in src/dbtPowerUserExtension.ts to handle parsing failures specifically
• When initializeDBTProjects() results in parsing timeout or error, display window.showErrorMessage() with descriptive message
• Include action buttons: "Retry", "Skip Parsing", "View Diagnostics", "Increase Timeout"
• Implement handlers for each action button:
  • "Retry" calls initializeDBTProjects() again
  • "Skip Parsing" proceeds with extension activation but marks projects as not parsed
  • "View Diagnostics" opens the diagnostics output channel
  • "Increase Timeout" opens workspace settings focused on dbt.parseTimeout

🤖 Prompt for AI agents

Add timeout protection to prevent indefinite hanging during manifest parsing and
provide user recovery options.

Add `dbt.parseTimeout` configuration setting to package.json (default 300000ms,
minimum 30000ms)

Create timeout wrapper utility in `src/utils/promiseTimeout.ts`:
- Accept Promise, timeout duration, and optional error message
- Use Promise.race() to race original promise against timeout
- Return typed result with success/timeout/error status and elapsed time

Modify `parseManifest()` in `src/dbt_client/dbtProject.ts`:
- Wrap `this.dbtProjectIntegration.parseManifest()` call with timeout utility
- Read timeout from workspace configuration
- Handle timeout errors separately from other parsing errors
- Log timeout events with project path and elapsed time
- Emit telemetry for parsing outcomes

Update activation flow in `src/dbtPowerUserExtension.ts`:
- Catch parsing failures and display `window.showErrorMessage()` with
descriptive message
- Add action buttons: "Retry", "Skip Parsing", "View Diagnostics", "Increase
Timeout"
- Implement button handlers (retry initialization, skip parsing, open
diagnostics channel, open settings)

Phase 2: Add Progress Monitoring with User Cancellation

This phase adds visibility into the parsing process and allows users to cancel the operation if it's taking too long or if they need to work without waiting for parsing to complete.

Task 1: Track Parsing Timestamps

Add timestamp tracking to the rebuild manifest status change events to enable progress monitoring.

• Extend RebuildManifestStatusChange interface in src/dbt_client/dbtProject.ts to include startTime: number | undefined (timestamp when parsing started)
• When emitting status change with inProgress: true, set startTime: Date.now()
• When emitting status change with inProgress: false, calculate and log duration
• Add duration to telemetry events for parsing operations

Task 2: Show Cancellable Progress Notification

Display a progress notification during manifest parsing that allows user cancellation.

• Modify initializeDBTProjects() in src/dbt_client/dbtProjectContainer.ts to use window.withProgress() wrapper with cancellable: true
• Progress notification message should indicate which projects are being parsed (e.g., "Parsing dbt projects (2 of 3)")
• Create and use CancellationTokenSource that allows user to cancel via progress notification
• When cancelled, reject the parsing promises and show info message: "Parsing cancelled. You can retry from the command palette."

Task 3: Handle Cancellation in Parsing Flow

Implement cancellation handling throughout the parsing operation chain.

• Pass CancellationToken from progress notification down through registerWorkspaceFolder() to discoverProjects() and parseManifest()
• Check token.isCancellationRequested at key points in the initialization flow
• If cancellation detected during parsing, clean up any in-progress operations and skip remaining projects
• Mark projects as "parsing cancelled" state to distinguish from successful parse or error states
• Update status bar to show appropriate state when parsing is cancelled

Task 4: Add Command to Retry Parsing

Create a command that allows users to manually trigger project parsing after cancellation or failure.

• Add new command dbtPowerUser.retryParsing to src/commands/ directory
• Command should call initializeDBTProjects() with fresh cancellation token
• Register command in src/extension.ts activation
• Add command to package.json contributions with title "dbt: Retry Project Parsing"
• Command should be available in command palette when extension is activated

🤖 Prompt for AI agents

Add cancellable progress monitoring to manifest parsing operations.

Extend `RebuildManifestStatusChange` interface in
`src/dbt_client/dbtProject.ts`:
- Add `startTime: number | undefined` field
- Set `startTime: Date.now()` when emitting `inProgress: true`
- Calculate and log duration when emitting `inProgress: false`
- Include duration in telemetry events

Modify `initializeDBTProjects()` in `src/dbt_client/dbtProjectContainer.ts`:
- Wrap with `window.withProgress()` using `cancellable: true`
- Show progress message indicating parsed project count
- Create `CancellationTokenSource` for user cancellation
- Show info message on cancellation

Implement cancellation throughout parsing flow:
- Thread `CancellationToken` through `registerWorkspaceFolder()`,
`discoverProjects()`, and `parseManifest()`
- Check `token.isCancellationRequested` at key points
- Clean up and skip remaining projects on cancellation
- Mark projects with "parsing cancelled" state
- Update status bar appropriately

Create retry command:
- Add `dbtPowerUser.retryParsing` command to `src/commands/`
- Call `initializeDBTProjects()` with fresh cancellation token
- Register in `src/extension.ts` and package.json with title "dbt: Retry Project
Parsing"

Phase 3: Enhanced Diagnostics and Error Context

This phase improves the diagnostic information available when parsing fails, making it easier for users and maintainers to identify root causes.

Task 1: Add Detailed Parsing Diagnostics

Enhance diagnostic logging to capture more context about parsing operations and failures.

• Extend diagnostic output in src/services/diagnosticsOutputChannel.ts to include parsing-specific section
• Log parsing start/end timestamps, duration, project paths, and dbt version for each parsing operation
• When timeout occurs, log: project details, timeout threshold, elapsed time, last status update timestamp, environment variables, Python path
• Include dbt command output (stderr/stdout) from the parsing operation if available via dbtProjectLog

Task 2: Detect and Report Common Parse Failure Patterns

Add pattern detection for common parsing failures to provide more specific error messages and recovery suggestions.

• In timeout handler in src/dbt_client/dbtProject.ts, analyze error context to detect common patterns:
  • Connection timeouts to data warehouse (check for "connection refused", "timeout" in error messages)
  • Missing dependencies (check for "module not found" patterns)
  • Invalid project configuration (check for "config" or "profile" errors)
  • Python environment issues (check for "python" or "environment" errors)
• Map detected patterns to user-friendly error messages with specific recovery steps
• Show pattern-specific error message in window.showErrorMessage() with relevant action buttons (e.g., "Check Connection" for connection errors, "Install Dependencies" for missing deps)

Task 3: Add Health Check for Stalled Parsing

Implement a monitoring mechanism to detect when parsing has stalled without completing or timing out.

• Create periodic health check in src/dbt_client/dbtProjectContainer.ts that monitors active parsing operations
• Check if any project has been in inProgress: true state for longer than expected threshold (e.g., 80% of timeout value)
• Log warning to diagnostics output channel when parsing appears stalled
• For stalled operations beyond threshold, show info notification: "Parsing is taking longer than expected. You can continue waiting or cancel and retry."
• Include diagnostic information about the stalled project (path, dbt version, time elapsed)

🤖 Prompt for AI agents

Enhance diagnostic information for parsing failures to aid debugging and user
recovery.

Extend `src/services/diagnosticsOutputChannel.ts`:
- Add parsing-specific diagnostic section
- Log start/end timestamps, duration, project paths, and dbt version
- On timeout, log project details, timeout threshold, elapsed time, last status
update, environment variables, Python path
- Include dbt command output (stderr/stdout) if available

Add failure pattern detection in `src/dbt_client/dbtProject.ts`:
- Analyze error messages for common patterns (connection timeouts, missing
dependencies, invalid config, Python environment issues)
- Map patterns to user-friendly error messages with recovery steps
- Show pattern-specific errors via `window.showErrorMessage()` with relevant
action buttons

Implement health check in `src/dbt_client/dbtProjectContainer.ts`:
- Create periodic monitor for active parsing operations
- Check if projects remain in `inProgress: true` beyond threshold (80% of
timeout)
- Log warnings for stalled operations
- Show info notification for stalled parsing with option to continue or cancel
- Include diagnostic info (path, dbt version, elapsed time)

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Add timeout protection to prevent indefinite hanging during manifest parsing and
provide user recovery options.

Add `dbt.parseTimeout` configuration setting to package.json (default 300000ms,
minimum 30000ms)

Create timeout wrapper utility in `src/utils/promiseTimeout.ts`:
- Accept Promise, timeout duration, and optional error message
- Use Promise.race() to race original promise against timeout
- Return typed result with success/timeout/error status and elapsed time

Modify `parseManifest()` in `src/dbt_client/dbtProject.ts`:
- Wrap `this.dbtProjectIntegration.parseManifest()` call with timeout utility
- Read timeout from workspace configuration
- Handle timeout errors separately from other parsing errors
- Log timeout events with project path and elapsed time
- Emit telemetry for parsing outcomes

Update activation flow in `src/dbtPowerUserExtension.ts`:
- Catch parsing failures and display `window.showErrorMessage()` with
descriptive message
- Add action buttons: "Retry", "Skip Parsing", "View Diagnostics", "Increase
Timeout"
- Implement button handlers (retry initialization, skip parsing, open
diagnostics channel, open settings)
===============================================================================

Task: 2

Add cancellable progress monitoring to manifest parsing operations.

Extend `RebuildManifestStatusChange` interface in
`src/dbt_client/dbtProject.ts`:
- Add `startTime: number | undefined` field
- Set `startTime: Date.now()` when emitting `inProgress: true`
- Calculate and log duration when emitting `inProgress: false`
- Include duration in telemetry events

Modify `initializeDBTProjects()` in `src/dbt_client/dbtProjectContainer.ts`:
- Wrap with `window.withProgress()` using `cancellable: true`
- Show progress message indicating parsed project count
- Create `CancellationTokenSource` for user cancellation
- Show info message on cancellation

Implement cancellation throughout parsing flow:
- Thread `CancellationToken` through `registerWorkspaceFolder()`,
`discoverProjects()`, and `parseManifest()`
- Check `token.isCancellationRequested` at key points
- Clean up and skip remaining projects on cancellation
- Mark projects with "parsing cancelled" state
- Update status bar appropriately

Create retry command:
- Add `dbtPowerUser.retryParsing` command to `src/commands/`
- Call `initializeDBTProjects()` with fresh cancellation token
- Register in `src/extension.ts` and package.json with title "dbt: Retry Project
Parsing"
===============================================================================

Task: 3

Enhance diagnostic information for parsing failures to aid debugging and user
recovery.

Extend `src/services/diagnosticsOutputChannel.ts`:
- Add parsing-specific diagnostic section
- Log start/end timestamps, duration, project paths, and dbt version
- On timeout, log project details, timeout threshold, elapsed time, last status
update, environment variables, Python path
- Include dbt command output (stderr/stdout) if available

Add failure pattern detection in `src/dbt_client/dbtProject.ts`:
- Analyze error messages for common patterns (connection timeouts, missing
dependencies, invalid config, Python environment issues)
- Map patterns to user-friendly error messages with recovery steps
- Show pattern-specific errors via `window.showErrorMessage()` with relevant
action buttons

Implement health check in `src/dbt_client/dbtProjectContainer.ts`:
- Create periodic monitor for active parsing operations
- Check if projects remain in `inProgress: true` beyond threshold (80% of
timeout)
- Log warnings for stalled operations
- Show info notification for stalled parsing with option to continue or cancel
- Include diagnostic info (path, dbt version, elapsed time)

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- @coderabbitai You can skip phase 3. Add a simple unit test case for phase 2.
- @coderabbitai For assumption 1 go ahead with option 3 and replan.

[Vgrunert]

Is there any way that a human can look into this? it tells me 'diagnostics completed successfully, but it remains in the parsing project loop:

also it parses all the extensions, which then throw an error:

[mdesmet]

Is there a problem for the actual project?