Getting error source

[troelsarvin]

I want to get to the source of an error. When I debug-print the error, I can see something called "source", and as I read isahc's documentation, isahc's Error shoud have a source method. However, I don't understand how to get to source.

Here's some code demonstrating what I'd like to to:

use isahc::prelude::*;
use std::time::Duration;

fn main() {
    let url = "https://www.kulturarv.dk/fundogfortidsminder/Lokalitet/125434/";

    let hclient = isahc::HttpClient::builder().
        timeout(Duration::from_secs(10)).
        build().
        unwrap();

    let response_res = hclient.get(url);

    if let Err(e) = response_res {
        println!("get returned error: {:?} of kind {}", e, e.kind());
    
    /* Fails to compile:

        let src = e.source();
        println!("src: {:?}", src);
    */
    }
}

When the code runs, it looks like this:

get returned error: Error { kind: Timeout, context: None, source: Some(Error { description: "Timeout was reached", code: 28, extra: None }), source_type: Some("curl::error::Error"), local_addr: Some(192.168.1.35:52578), remote_addr: Some(95.128.26.76:443) } of kind request or operation took longer than the configured timeout time

If I uncomment the code where I try to get to the source, I get the following error:

error[E0599]: no method named `source` found for struct `isahc::Error` in the current scope
   --> src/main.rs:17:21
    |
17  |         let src = e.source();
    |                     ^^^^^^ method not found in `isahc::Error`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following trait is implemented but not in scope; perhaps add a `use` for it:
    |
1   | use std::error::Error;
    |

For more information about this error, try `rustc --explain E0599`.
error: could not compile `rust-test` due to previous error

What am I misunderstanding?

[sagebind]

You need to import the standard Error trait as the compiler suggests, because the source method is defined as part of the std::error::Error trait: https://doc.rust-lang.org/stable/std/error/trait.Error.html#method.source.

[troelsarvin]

OK, thanks. What I really need is the "code" field from the error. I don't understand how to pull that from &dyn std::error::Error.

This is my code now:

use isahc::prelude::*;
use std::time::Duration;
use std::error::Error;

fn main() {
    let url = "https://odder-golfcafe.dk/";

    let hclient = isahc::HttpClient::builder().
        timeout(Duration::from_secs(10)).
        build().
        unwrap();

    let response_res = hclient.get(url);

    if let Err(e) = response_res {
        if let Some(src) = e.source() {

            println!("src: {:?}", src);

            // Prints:
            // src: Error { description: "Couldn't resolve host name", code: 6, extra: None }
            //
            // src has this type: &dyn std::error::Error

            // let code = ??
        }
    }
}

[sagebind]

The source of an isahc::error::Error is an underlying error (implementing std::error::Error) emitted at a lower level that may have caused the higher-level Isahc error to be returned. We don't guarantee that the source is present, and if it is present, we don't guarantee that it will be of a particular type, since that would make it difficult for us to change the implementation details of Isahc. Keep this in mind when trying to introspect errors.

If you just want to know what kind of error it is, then I recommend using the isahc::error::Error::kind method, which returns potentially one of the enum variants in ErrorKind that broadly classify what failed. For example, if you just want to know if the error is caused by a timeout, you could do

if let Err(e) = response_res {
    match e.kind() {
        ErrorKind::Timeout => { /* timeout expired */ }
        _ => { /* some other error */ }
    }
}

Or if you only care about checking for timeouts, isahc::error::Error has plenty of convenience methods for checking the kind of error such as is_timeout:

if let Err(e) = response_res {
    if e.is_timeout() {
        /* do something about timeout expired */
    } else {
        /* some other error */
    }
}

There are a lot of variants in ErrorKind to help users identify the kind of problem that is occurring; in your case you probably are looking for ErrorKind::NameResolution. If you're attempting to classify a particular kind of error that doesn't have an equivalent variant in ErrorKind then we'd be happy to add a new one in most cases.

However, if you really actually need to get the underlying error code (which isn't always as meaningful as you think): In this case the source is an instance of curl::Error, and the code on that type is a libcurl error code. To access it, we'd get access to the source first and then try to downcast it into curl::Error:

if let Err(e) = response_res {
    // Check if the error has a source
    if let Some(src) = e.source() {
        // Check if the source is an instance of `curl::Error`
        if let Some(curl_error) = src.downcast_ref::<curl::Error>() {
            // Now we have a `&curl::Error` and can do things with it.
            let code = curl_error.code();
            // Do something with the code?
        }
    }
}

Again, unless you specifically need a CURLcode for something it is probably not the best way, since Isahc already inspects the CURL error code in order to decide what ErrorKind to return at a higher level.

[troelsarvin]

Hello Stephen, thanks, that was what I was looking for. I need to store both kind and underlying error code.