Enum AnalyzeError 

pub enum AnalyzeError {
    Config(String),
    Pool {
        url: String,
        message: String,
    },
    Db(String),
    Io(Error),
    Json(Error),
}

Errors surfaced by run / fetch_table_health. Each variant carries operator-actionable context — the goal is that an eprintln!("djogi analyze: {e}") line is enough to diagnose without grepping source. Mirrors verify::VerifyError’s shape.

Variants

Config(String)

Loading Djogi.toml (and its env overlays) failed.

Pool

Could not connect to the application database. URL is included for diagnostics; the underlying DjogiError is rendered into message so AnalyzeError stays Send + Sync regardless of the variant we received.

Fields

url: String

The application DB URL we attempted to reach. Echoed in the operator-facing message so the resolution path is visible.

message: String

Underlying error message. The framework’s DjogiError::Pool enum carries trait-object inner values that aren’t always Send + Sync; rendering eagerly keeps AnalyzeError cheap to clone in test assertions and avoids leaking deadpool types to consumers.

Db(String)

pg_stat_user_tables query (or the optional pg_partman join) surfaced a Postgres error that is NOT one of the “extension absent” SQLSTATEs we tolerate. Rendered eagerly for the same reasons as Pool::message.

Io(Error)

Writing the rendered output to stdout failed (broken pipe, disk full on a redirected > file.json, etc.).

Json(Error)

serde_json encoding failed. Should be unreachable because the Row projection only contains primitive / OffsetDateTime / known-Serialize types, but we surface it as a structured variant rather than unwrap() so a future schema extension that introduces a non-serialisable field fails loudly.

Trait Implementations

impl Debug for AnalyzeError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for AnalyzeError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Every variant ships an operator-actionable remediation hint after the cause — eprintln!("djogi analyze: {e}") should be enough to either fix the problem or know what to file. The shape is “. …”. The analyze_error_display_is_operator_actionable test pins each variant’s remediation keyword (Verify / Check / file an issue) so a future drift trips the test rather than silently losing the hint.

impl Error for AnalyzeError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Error> for AnalyzeError

fn from(e: Error) -> Self

Converts to this type from the input type.

impl From<Error> for AnalyzeError

fn from(e: Error) -> Self

Converts to this type from the input type.