Method http_request

crates/core/src/host/instance_env.rs:855–1008

Perform an HTTP request. Exposed to modules via the `ProcedureContext`. It's very important that the error returned from this function not contain any potentially sensitive data from `request`, such as the query parameters or header values. This way, it's safe to log the errors (either for us to do so, or for module code to do so), and less dangerous to send them to the calling client of a proced

(
        &mut self,
        request: st_http::Request,
        body: bytes::Bytes,
    )

    /// This way, it's safe to log the errors (either for us to do so, or for module code to do so),
    /// and less dangerous to send them to the calling client of a procedure.
    pub fn http_request(
        &mut self,
        request: st_http::Request,
        body: bytes::Bytes,
    ) -> Result<impl Future<Output = Result<(st_http::Response, bytes::Bytes), NodesError>> + use<>, NodesError> {
        if self.in_tx() {
            // If we're holding a transaction open, refuse to perform this blocking operation.
            return Err(NodesError::WouldBlockTransaction(super::AbiCall::ProcedureHttpRequest));
        }

        // Record in metrics that we're starting an HTTP request.
        DB_METRICS
            .procedure_num_http_requests
            .with_label_values(self.database_identity())
            .inc();
        DB_METRICS
            .procedure_http_request_size_bytes
            .with_label_values(self.database_identity())
            .inc_by((request.size_in_bytes() + body.len()) as _);
        // Make a guard for the `in_progress` metric that will be decremented on exit.
        let _in_progress_metric = DB_METRICS
            .procedure_num_in_progress_http_requests
            .with_label_values(self.database_identity())
            .inc_scope();

        /// Strip the query part out of the URL in `err`, as query parameters may be sensitive
        /// and we'd like it to be safe to directly log errors from this method.
        fn strip_query_params_from_reqwest_error(mut err: reqwest::Error) -> reqwest::Error {
            if let Some(url) = err.url_mut() {
                // `set_query` of `None` clears the query part.
                url.set_query(None);
            }
            err
        }

        fn http_error<E: std::error::Error>(err: E) -> NodesError {
            // Include the full error chain, not just the top-level message.
            // `reqwest::Error` wraps underlying causes (DNS failure, connection refused,
            // timeout, TLS errors, etc.) which are essential for debugging.
            use std::fmt::Write;
            let mut message = err.to_string();
            let mut source = err.source();
            while let Some(cause) = source {
                write!(message, ": {cause}").unwrap();
                source = cause.source();
            }
            NodesError::HttpError(message)
        }

        // Then convert the request into an `http::Request`, a semi-standard "lingua franca" type in the Rust ecosystem,
        // and map its body into a type `reqwest` will like.
        //
        // See comments on and in `convert_http_request` for justification that there's no sensitive info in this error.
        let (request, timeout) = convert_http_request(request).map_err(http_error)?;

        let request = http::Request::from_parts(request, body);

        let mut reqwest: reqwest::Request = request