Integrate RetryPolicy into PostgreSQL Query Execution

[unclesp1d3r]

Integrate RetryPolicy into PostgreSQL Query Execution

Overview

Add per-query retry logic to PostgreSQL adapter using RetryPolicy trait. This enables automatic recovery from transient database errors while avoiding retry storms on permission errors.

Scope

What's Included:

• Create query execution wrapper in file:dbsurveyor-core/src/adapters/postgres/mod.rs:
  • execute_with_retry<T, F>(&self, operation: F, retry_policy: &dyn RetryPolicy) -> Result<T>
  • Generic wrapper that applies retry logic to any async database operation
• Categorize SQLx errors into ErrorCategory:
  • sqlx::Error::Database with code "42501" → ErrorCategory::Permission
  • sqlx::Error::PoolTimedOut, sqlx::Error::PoolClosed → ErrorCategory::Timeout
  • sqlx::Error::Io → ErrorCategory::Connection
  • Other errors → ErrorCategory::Other
• Apply retry logic to all schema collection queries in file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs:
  • collect_database_info() queries
  • collect_schemas() query
  • collect_tables() query
  • collect_table_columns(), collect_table_indexes(), collect_table_constraints(), collect_table_primary_key(), collect_table_foreign_keys()
  • Views, routines, triggers queries in respective modules
• Record retry attempts and final backoff in error context (for future ObjectFailure population)
• Log retry attempts at debug level: "Retrying query after {backoff}ms (attempt {attempt}/{max})"
• Unit tests for error categorization (verify all SQLx error types map correctly)
• Integration tests verifying retry behavior with testcontainers:
  • Simulate transient timeout (verify retry occurs)
  • Simulate permission error (verify no retry)
  • Verify exponential backoff timing

What's Explicitly Out:

• Retry logic for MySQL/SQLite adapters (separate work)
• Configurable retry parameters (using hardcoded defaults from ticket:de2eeeb8-bfeb-4a11-98aa-84efc70568b2/2)
• Connection pool retry (focus on query-level retry only)
• Population of ObjectFailure metadata (handled in ticket:de2eeeb8-bfeb-4a11-98aa-84efc70568b2/7)

Retry Wrapper Pattern

async fn execute_with_retry<T, F, Fut>(
    operation: F,
    retry_policy: &dyn RetryPolicy,
) -> Result<T>
where
    F: Fn() -> Fut,
    Fut: Future<Output = Result<T>>,
{
    let mut attempt = 0;
    loop {
        match operation().await {
            Ok(result) => return Ok(result),
            Err(e) => {
                let category = categorize_error(&e);
                if !retry_policy.should_retry(category, attempt) {
                    return Err(e);
                }
                let backoff = retry_policy.backoff_duration(attempt);
                tokio::time::sleep(backoff).await;
                attempt += 1;
            }
        }
    }
}

Acceptance Criteria

• All PostgreSQL schema collection queries use retry wrapper
• Permission errors (SQLx code "42501") are categorized as ErrorCategory::Permission and not retried
• Timeout errors are categorized as ErrorCategory::Timeout and retried up to 3 times
• Connection errors are retried with exponential backoff (500ms, 1000ms, 2000ms + jitter)
• Retry attempts and backoff durations are logged at debug level
• Unit tests verify error categorization for all SQLx error variants
• Integration test verifies retry behavior with simulated transient failures (using testcontainers)
• Integration test verifies no retry on permission errors

References

• Spec: spec:de2eeeb8-bfeb-4a11-98aa-84efc70568b2/820ca524-8c7d-4939-8097-f1158e7d67ea (Tech Plan - RetryPolicy Trait, Adapter Integration)
• Core Flows: spec:de2eeeb8-bfeb-4a11-98aa-84efc70568b2/661dbe3d-b679-4287-991e-26f4a0dd98b9 (Flow 6 - retry transient errors)

[traycerai]

Plan

Observations

The codebase currently has no retry infrastructure. The PostgreSQL adapter performs schema collection through multiple query methods in file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs, file:dbsurveyor-core/src/adapters/postgres/views.rs, file:dbsurveyor-core/src/adapters/postgres/routines.rs, and file:dbsurveyor-core/src/adapters/postgres/triggers.rs. Error handling already distinguishes SQLx error code "42501" for permission errors. The project uses SQLx for database operations, tokio for async runtime, and testcontainers for integration testing. All schema collection queries use sqlx::query() with .fetch_all() or .fetch_one() patterns.

Approach

Implement a trait-based retry system with error categorization to enable automatic recovery from transient database failures. Create a RetryPolicy trait and ErrorCategory enum in a new retry module, then integrate it into the PostgreSQL adapter through a generic execute_with_retry() wrapper. Apply this wrapper to all schema collection queries while preserving existing error handling patterns. The implementation follows the existing codebase patterns: trait-based abstractions, comprehensive error handling with credential sanitization, and testcontainer-based integration tests.

Implementation Steps

1. Create Retry Infrastructure Module

File: file:dbsurveyor-core/src/adapters/retry.rs

Create a new module containing:

• ErrorCategory enum with variants:

  • Permission - for authorization failures (no retry)
  • Timeout - for connection/query timeouts (retry)
  • Connection - for network/IO errors (retry)
  • Other - for unknown errors (no retry by default)

• RetryPolicy trait with methods:

  • should_retry(&self, category: ErrorCategory, attempt: u32) -> bool - determines if retry should occur
  • backoff_duration(&self, attempt: u32) -> Duration - calculates backoff delay
  • max_attempts(&self) -> u32 - returns maximum retry attempts

• DefaultRetryPolicy struct implementing RetryPolicy with:

  • Max attempts: 3
  • Base backoff: 500ms
  • Exponential backoff: 500ms, 1000ms, 2000ms
  • Jitter: ±10% randomization to prevent thundering herd
  • Retry on: Timeout, Connection
  • No retry on: Permission, Other

Add comprehensive unit tests verifying:

• Error category matching logic
• Backoff calculation (exponential with jitter)
• Retry decision logic for each category
• Max attempts enforcement

2. Implement SQLx Error Categorization

File: file:dbsurveyor-core/src/adapters/retry.rs

Create categorize_sqlx_error() function that maps sqlx::Error to ErrorCategory:

• sqlx::Error::Database with code "42501" → ErrorCategory::Permission
• sqlx::Error::PoolTimedOut → ErrorCategory::Timeout
• sqlx::Error::PoolClosed → ErrorCategory::Timeout
• sqlx::Error::Io → ErrorCategory::Connection
• All other errors → ErrorCategory::Other

Add unit tests covering all SQLx error variants to ensure correct categorization.

3. Create Generic Retry Wrapper

File: file:dbsurveyor-core/src/adapters/postgres/mod.rs

Add execute_with_retry() method to PostgresAdapter:

async fn execute_with_retry<T, F, Fut>(
    &self,
    operation: F,
    retry_policy: &dyn RetryPolicy,
) -> Result<T>
where
    F: Fn() -> Fut,
    Fut: Future<Output = Result<T>>,

Implementation logic:

• Loop through retry attempts (0 to max_attempts)
• Execute the operation
• On success, return result immediately
• On error:
  • Categorize the error using categorize_sqlx_error()
  • Check retry_policy.should_retry(category, attempt)
  • If no retry, return error immediately
  • If retry, calculate backoff with retry_policy.backoff_duration(attempt)
  • Log at debug level: "Retrying query after {backoff}ms (attempt {attempt}/{max})"
  • Sleep for backoff duration using tokio::time::sleep()
  • Continue to next iteration

Store retry metadata (attempts, final backoff) in error context for future ObjectFailure population.

4. Apply Retry Logic to Database Info Collection

File: file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs

Modify collect_database_info() method:

• Create DefaultRetryPolicy instance
• Wrap version query execution in execute_with_retry()
• Wrap database info query execution in execute_with_retry()
• Preserve existing error handling and context

5. Apply Retry Logic to Schema Enumeration

File: file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs

Modify collect_schemas() method:

• Create DefaultRetryPolicy instance
• Wrap schema query execution in execute_with_retry()
• Preserve existing permission error detection (code "42501")
• Maintain existing error context and logging

6. Apply Retry Logic to Table Collection

File: file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs

Modify collect_tables() method:

• Create DefaultRetryPolicy instance
• Wrap tables query execution in execute_with_retry()
• Preserve existing permission error handling

Modify table detail collection methods:

• collect_table_columns() - wrap column query in retry
• collect_table_indexes() - wrap index query in retry
• collect_table_constraints() - wrap constraint query in retry
• collect_table_primary_key() - wrap PK query in retry
• collect_table_foreign_keys() - wrap FK query in retry

7. Apply Retry Logic to Views Collection

File: file:dbsurveyor-core/src/adapters/postgres/views.rs

Modify collect_views() function:

• Accept retry_policy: &dyn RetryPolicy parameter
• Wrap views query execution in retry logic
• Update collect_view_columns() to use retry wrapper

Update caller in file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs to pass retry policy.

8. Apply Retry Logic to Routines Collection

File: file:dbsurveyor-core/src/adapters/postgres/routines.rs

Modify collect_functions() and collect_procedures():

• Accept retry_policy: &dyn RetryPolicy parameter
• Wrap version query in retry logic
• Wrap function/procedure queries in retry logic

Update callers in file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs to pass retry policy.

9. Apply Retry Logic to Triggers Collection

File: file:dbsurveyor-core/src/adapters/postgres/triggers.rs

Modify collect_triggers() function:

• Accept retry_policy: &dyn RetryPolicy parameter
• Wrap triggers query execution in retry logic

Update caller in file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs to pass retry policy.

10. Update Module Exports

File: file:dbsurveyor-core/src/adapters/mod.rs

Add retry module:

pub mod retry;
pub use retry::{RetryPolicy, ErrorCategory, DefaultRetryPolicy};

File: file:dbsurveyor-core/src/lib.rs

Re-export retry types for public API:

pub use adapters::{RetryPolicy, ErrorCategory, DefaultRetryPolicy};

11. Write Unit Tests for Error Categorization

File: file:dbsurveyor-core/src/adapters/retry.rs (test module)

Create comprehensive unit tests:

• test_categorize_permission_error() - verify "42501" maps to Permission
• test_categorize_timeout_errors() - verify PoolTimedOut/PoolClosed map to Timeout
• test_categorize_connection_error() - verify Io errors map to Connection
• test_categorize_other_errors() - verify unknown errors map to Other
• test_default_retry_policy_should_retry() - verify retry decisions for each category
• test_default_retry_policy_backoff() - verify exponential backoff calculation
• test_default_retry_policy_max_attempts() - verify max attempts enforcement
• test_backoff_jitter() - verify jitter is within ±10% range

12. Write Integration Tests for Retry Behavior

File: file:dbsurveyor-core/tests/postgres_retry.rs

Create new integration test file with testcontainers:

Test 1: Verify Retry on Transient Timeout

• Start PostgreSQL container
• Create adapter with very short query timeout
• Execute query that will timeout
• Verify retry occurs (check debug logs)
• Verify exponential backoff timing
• Verify eventual success or max attempts reached

Test 2: Verify No Retry on Permission Error

• Start PostgreSQL container
• Create restricted user with limited privileges
• Attempt schema collection with restricted user
• Verify permission error (42501) is detected
• Verify NO retry occurs (check logs)
• Verify error is returned immediately

Test 3: Verify Retry on Connection Error

• Start PostgreSQL container
• Simulate connection pool exhaustion
• Verify retry occurs with Connection category
• Verify backoff timing
• Verify eventual recovery

Test 4: Verify Retry Metadata in Error Context

• Trigger a failure scenario
• Verify error context contains retry attempt count
• Verify error context contains final backoff duration
• Ensure this metadata is available for future ObjectFailure population

13. Update Documentation

File: file:dbsurveyor-core/src/adapters/retry.rs

Add comprehensive module documentation:

• Overview of retry strategy
• Error categorization logic
• Backoff algorithm explanation
• Usage examples
• Security considerations (no credential exposure in retry logs)

File: file:dbsurveyor-core/src/adapters/postgres/mod.rs

Update module documentation to mention retry capabilities:

• Document automatic retry behavior
• List which errors are retried
• Explain backoff strategy
• Note that permission errors are not retried

Sequence Diagram

sequenceDiagram
    participant Client
    participant PostgresAdapter
    participant RetryWrapper
    participant RetryPolicy
    participant Database

    Client->>PostgresAdapter: collect_schema()
    PostgresAdapter->>PostgresAdapter: collect_database_info()
    PostgresAdapter->>RetryWrapper: execute_with_retry(query_operation)
    
    loop Retry Loop (max 3 attempts)
        RetryWrapper->>Database: Execute Query
        alt Success
            Database-->>RetryWrapper: Result
            RetryWrapper-->>PostgresAdapter: Success
        else Transient Error (Timeout/Connection)
            Database-->>RetryWrapper: Error
            RetryWrapper->>RetryWrapper: categorize_error() → Timeout
            RetryWrapper->>RetryPolicy: should_retry(Timeout, attempt)
            RetryPolicy-->>RetryWrapper: true
            RetryWrapper->>RetryPolicy: backoff_duration(attempt)
            RetryPolicy-->>RetryWrapper: 500ms/1000ms/2000ms
            RetryWrapper->>RetryWrapper: Log retry attempt
            RetryWrapper->>RetryWrapper: Sleep(backoff + jitter)
        else Permission Error (42501)
            Database-->>RetryWrapper: Error
            RetryWrapper->>RetryWrapper: categorize_error() → Permission
            RetryWrapper->>RetryPolicy: should_retry(Permission, attempt)
            RetryPolicy-->>RetryWrapper: false
            RetryWrapper-->>PostgresAdapter: Error (no retry)
        end
    end
    
    PostgresAdapter->>PostgresAdapter: collect_schemas() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_tables() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_views() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_routines() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_triggers() [with retry]
    PostgresAdapter-->>Client: DatabaseSchema

Loading

Import In IDE

🤖 Prompt for AI Agents

## Observations

The codebase currently has no retry infrastructure. The PostgreSQL adapter performs schema collection through multiple query methods in `file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs`, `file:dbsurveyor-core/src/adapters/postgres/views.rs`, `file:dbsurveyor-core/src/adapters/postgres/routines.rs`, and `file:dbsurveyor-core/src/adapters/postgres/triggers.rs`. Error handling already distinguishes SQLx error code "42501" for permission errors. The project uses SQLx for database operations, tokio for async runtime, and testcontainers for integration testing. All schema collection queries use `sqlx::query()` with `.fetch_all()` or `.fetch_one()` patterns.

## Approach

Implement a trait-based retry system with error categorization to enable automatic recovery from transient database failures. Create a `RetryPolicy` trait and `ErrorCategory` enum in a new retry module, then integrate it into the PostgreSQL adapter through a generic `execute_with_retry()` wrapper. Apply this wrapper to all schema collection queries while preserving existing error handling patterns. The implementation follows the existing codebase patterns: trait-based abstractions, comprehensive error handling with credential sanitization, and testcontainer-based integration tests.

## Implementation Steps

### 1. Create Retry Infrastructure Module

**File**: `file:dbsurveyor-core/src/adapters/retry.rs`

Create a new module containing:

- **ErrorCategory enum** with variants:
  - `Permission` - for authorization failures (no retry)
  - `Timeout` - for connection/query timeouts (retry)
  - `Connection` - for network/IO errors (retry)
  - `Other` - for unknown errors (no retry by default)

- **RetryPolicy trait** with methods:
  - `should_retry(&self, category: ErrorCategory, attempt: u32) -> bool` - determines if retry should occur
  - `backoff_duration(&self, attempt: u32) -> Duration` - calculates backoff delay
  - `max_attempts(&self) -> u32` - returns maximum retry attempts

- **DefaultRetryPolicy struct** implementing RetryPolicy with:
  - Max attempts: 3
  - Base backoff: 500ms
  - Exponential backoff: 500ms, 1000ms, 2000ms
  - Jitter: ±10% randomization to prevent thundering herd
  - Retry on: `Timeout`, `Connection`
  - No retry on: `Permission`, `Other`

Add comprehensive unit tests verifying:
- Error category matching logic
- Backoff calculation (exponential with jitter)
- Retry decision logic for each category
- Max attempts enforcement

### 2. Implement SQLx Error Categorization

**File**: `file:dbsurveyor-core/src/adapters/retry.rs`

Create `categorize_sqlx_error()` function that maps `sqlx::Error` to `ErrorCategory`:

- `sqlx::Error::Database` with code "42501" → `ErrorCategory::Permission`
- `sqlx::Error::PoolTimedOut` → `ErrorCategory::Timeout`
- `sqlx::Error::PoolClosed` → `ErrorCategory::Timeout`
- `sqlx::Error::Io` → `ErrorCategory::Connection`
- All other errors → `ErrorCategory::Other`

Add unit tests covering all SQLx error variants to ensure correct categorization.

### 3. Create Generic Retry Wrapper

**File**: `file:dbsurveyor-core/src/adapters/postgres/mod.rs`

Add `execute_with_retry()` method to `PostgresAdapter`:

```rust
async fn execute_with_retry<T, F, Fut>(
    &self,
    operation: F,
    retry_policy: &dyn RetryPolicy,
) -> Result<T>
where
    F: Fn() -> Fut,
    Fut: Future<Output = Result<T>>,
```

Implementation logic:
- Loop through retry attempts (0 to max_attempts)
- Execute the operation
- On success, return result immediately
- On error:
  - Categorize the error using `categorize_sqlx_error()`
  - Check `retry_policy.should_retry(category, attempt)`
  - If no retry, return error immediately
  - If retry, calculate backoff with `retry_policy.backoff_duration(attempt)`
  - Log at debug level: "Retrying query after {backoff}ms (attempt {attempt}/{max})"
  - Sleep for backoff duration using `tokio::time::sleep()`
  - Continue to next iteration

Store retry metadata (attempts, final backoff) in error context for future `ObjectFailure` population.

### 4. Apply Retry Logic to Database Info Collection

**File**: `file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs`

Modify `collect_database_info()` method:
- Create `DefaultRetryPolicy` instance
- Wrap version query execution in `execute_with_retry()`
- Wrap database info query execution in `execute_with_retry()`
- Preserve existing error handling and context

### 5. Apply Retry Logic to Schema Enumeration

**File**: `file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs`

Modify `collect_schemas()` method:
- Create `DefaultRetryPolicy` instance
- Wrap schema query execution in `execute_with_retry()`
- Preserve existing permission error detection (code "42501")
- Maintain existing error context and logging

### 6. Apply Retry Logic to Table Collection

**File**: `file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs`

Modify `collect_tables()` method:
- Create `DefaultRetryPolicy` instance
- Wrap tables query execution in `execute_with_retry()`
- Preserve existing permission error handling

Modify table detail collection methods:
- `collect_table_columns()` - wrap column query in retry
- `collect_table_indexes()` - wrap index query in retry
- `collect_table_constraints()` - wrap constraint query in retry
- `collect_table_primary_key()` - wrap PK query in retry
- `collect_table_foreign_keys()` - wrap FK query in retry

### 7. Apply Retry Logic to Views Collection

**File**: `file:dbsurveyor-core/src/adapters/postgres/views.rs`

Modify `collect_views()` function:
- Accept `retry_policy: &dyn RetryPolicy` parameter
- Wrap views query execution in retry logic
- Update `collect_view_columns()` to use retry wrapper

Update caller in `file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs` to pass retry policy.

### 8. Apply Retry Logic to Routines Collection

**File**: `file:dbsurveyor-core/src/adapters/postgres/routines.rs`

Modify `collect_functions()` and `collect_procedures()`:
- Accept `retry_policy: &dyn RetryPolicy` parameter
- Wrap version query in retry logic
- Wrap function/procedure queries in retry logic

Update callers in `file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs` to pass retry policy.

### 9. Apply Retry Logic to Triggers Collection

**File**: `file:dbsurveyor-core/src/adapters/postgres/triggers.rs`

Modify `collect_triggers()` function:
- Accept `retry_policy: &dyn RetryPolicy` parameter
- Wrap triggers query execution in retry logic

Update caller in `file:dbsurveyor-core/src/adapters/postgres/schema_collection.rs` to pass retry policy.

### 10. Update Module Exports

**File**: `file:dbsurveyor-core/src/adapters/mod.rs`

Add retry module:
```rust
pub mod retry;
pub use retry::{RetryPolicy, ErrorCategory, DefaultRetryPolicy};
```

**File**: `file:dbsurveyor-core/src/lib.rs`

Re-export retry types for public API:
```rust
pub use adapters::{RetryPolicy, ErrorCategory, DefaultRetryPolicy};
```

### 11. Write Unit Tests for Error Categorization

**File**: `file:dbsurveyor-core/src/adapters/retry.rs` (test module)

Create comprehensive unit tests:
- `test_categorize_permission_error()` - verify "42501" maps to Permission
- `test_categorize_timeout_errors()` - verify PoolTimedOut/PoolClosed map to Timeout
- `test_categorize_connection_error()` - verify Io errors map to Connection
- `test_categorize_other_errors()` - verify unknown errors map to Other
- `test_default_retry_policy_should_retry()` - verify retry decisions for each category
- `test_default_retry_policy_backoff()` - verify exponential backoff calculation
- `test_default_retry_policy_max_attempts()` - verify max attempts enforcement
- `test_backoff_jitter()` - verify jitter is within ±10% range

### 12. Write Integration Tests for Retry Behavior

**File**: `file:dbsurveyor-core/tests/postgres_retry.rs`

Create new integration test file with testcontainers:

**Test 1: Verify Retry on Transient Timeout**
- Start PostgreSQL container
- Create adapter with very short query timeout
- Execute query that will timeout
- Verify retry occurs (check debug logs)
- Verify exponential backoff timing
- Verify eventual success or max attempts reached

**Test 2: Verify No Retry on Permission Error**
- Start PostgreSQL container
- Create restricted user with limited privileges
- Attempt schema collection with restricted user
- Verify permission error (42501) is detected
- Verify NO retry occurs (check logs)
- Verify error is returned immediately

**Test 3: Verify Retry on Connection Error**
- Start PostgreSQL container
- Simulate connection pool exhaustion
- Verify retry occurs with Connection category
- Verify backoff timing
- Verify eventual recovery

**Test 4: Verify Retry Metadata in Error Context**
- Trigger a failure scenario
- Verify error context contains retry attempt count
- Verify error context contains final backoff duration
- Ensure this metadata is available for future `ObjectFailure` population

### 13. Update Documentation

**File**: `file:dbsurveyor-core/src/adapters/retry.rs`

Add comprehensive module documentation:
- Overview of retry strategy
- Error categorization logic
- Backoff algorithm explanation
- Usage examples
- Security considerations (no credential exposure in retry logs)

**File**: `file:dbsurveyor-core/src/adapters/postgres/mod.rs`

Update module documentation to mention retry capabilities:
- Document automatic retry behavior
- List which errors are retried
- Explain backoff strategy
- Note that permission errors are not retried

## Sequence Diagram

```mermaid
sequenceDiagram
    participant Client
    participant PostgresAdapter
    participant RetryWrapper
    participant RetryPolicy
    participant Database

    Client->>PostgresAdapter: collect_schema()
    PostgresAdapter->>PostgresAdapter: collect_database_info()
    PostgresAdapter->>RetryWrapper: execute_with_retry(query_operation)
    
    loop Retry Loop (max 3 attempts)
        RetryWrapper->>Database: Execute Query
        alt Success
            Database-->>RetryWrapper: Result
            RetryWrapper-->>PostgresAdapter: Success
        else Transient Error (Timeout/Connection)
            Database-->>RetryWrapper: Error
            RetryWrapper->>RetryWrapper: categorize_error() → Timeout
            RetryWrapper->>RetryPolicy: should_retry(Timeout, attempt)
            RetryPolicy-->>RetryWrapper: true
            RetryWrapper->>RetryPolicy: backoff_duration(attempt)
            RetryPolicy-->>RetryWrapper: 500ms/1000ms/2000ms
            RetryWrapper->>RetryWrapper: Log retry attempt
            RetryWrapper->>RetryWrapper: Sleep(backoff + jitter)
        else Permission Error (42501)
            Database-->>RetryWrapper: Error
            RetryWrapper->>RetryWrapper: categorize_error() → Permission
            RetryWrapper->>RetryPolicy: should_retry(Permission, attempt)
            RetryPolicy-->>RetryWrapper: false
            RetryWrapper-->>PostgresAdapter: Error (no retry)
        end
    end
    
    PostgresAdapter->>PostgresAdapter: collect_schemas() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_tables() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_views() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_routines() [with retry]
    PostgresAdapter->>PostgresAdapter: collect_triggers() [with retry]
    PostgresAdapter-->>Client: DatabaseSchema
```

---

Execution Information

Branch: main
Commit: 4888501

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[coderabbitai]

📝 CodeRabbit Plan Mode

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

• Create Plan

Examples

• Example 1
• Example 2

---

⚠️ Possible Duplicate Issue

• Integrate RetryPolicy into PostgreSQL Query Execution #80

🔗 Related PRs

#51 - feat(collector): implement unified database adapters with feature flag architecture for all 6 database engines [merged]

---

🧪 Issue enrichment is currently in open beta.

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

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!