relay.span-normalization.allowed_hosts global options failed to deserialized

[aldy505]

I implemented this a while back: #3813

On 24.8.0 (self-hosted), it turns out String or &str can't be properly deserialized into Host type. There's this upstream issue on the url crate: servo/rust-url#543 and servo/rust-url#895.

The solution is quite simple, we'll just have to override the deserialize method for Host specifically. We'll just need to implement a custom deserializer function and change this specific line:

relay/relay-dynamic-config/src/global.rs

Line 223 in 92c008e

deserialize_with = "default_on_error",

I made a working repro:

Cargo.toml

[package]
name = "rust-host-vec"
version = "0.1.0"
edition = "2021"

[dependencies]
serde_json = "1"
serde = { version = "1.0.159", features = ["derive", "rc"] }
serde-transcode = "1.1.1"
url = { version = "2", features = ["serde"] }

src/main.rs

use std::fmt;

use serde::{de, Deserialize};
use url::Host;

#[derive(Default, Clone, Debug, Deserialize, PartialEq)]
#[serde(default)]
pub struct GlobalConfig {
    #[serde(
        rename = "relay.span-normalization.allowed_hosts",
        deserialize_with = "deserialize_host",
        skip_serializing_if = "Vec::is_empty"
    )]
    pub http_span_allowed_hosts: Vec<Host>,
}

fn deserialize_host<'de, D>(deserializer: D) -> Result<Vec<Host>, D::Error>
where
    D: serde::de::Deserializer<'de>,
{
    // Stolen from https://users.rust-lang.org/t/need-help-with-serde-deserialize-with/18374
    struct HostVisitor;

    impl<'de> de::Visitor<'de> for HostVisitor {
        type Value = Vec<Host>;

        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
            formatter.write_str("a string containing host data")
        }

        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
        where
            A: de::SeqAccess<'de>,
        {
            let mut values = Vec::<Host>::new();
            while let Some(value) = seq.next_element()? {
                let this = Host::parse(value);
                let op = de::Error::custom;
                match this {
                    Ok(t) => values.push(t),
                    Err(e) => return Err(op(e)),
                }
            }

            Ok(values)
        }
    }

    deserializer.deserialize_any(HostVisitor)
}

fn main() {
    let input = r###"{
        "relay.span-normalization.allowed_hosts": [
            "vault.internal.example.com"
        ]
      }"###;

    match serde_json::from_str::<GlobalConfig>(input) {
        Ok(config) => {
            println!("{:?}", config);
        }
        Err(e) => {
            println!("{:?}", e);
        }
    }
}

Might work on this later this weekend, or the next weekend. I can't work on this right now since I got work to do. Also I guess I need to write few tests here and there for deserializing the new global option I made 😒

[aldy505]

Figured gonna do it this weekend and brace myself to use nightly...