relay_event_normalization/eap/

mod.rs

//! Event normalization and processing for attribute (EAP) based payloads.
//!
//! A central place for all modifications/normalizations for attributes.

use std::borrow::Cow;
use std::fmt;
use std::net::IpAddr;

use chrono::{DateTime, Utc};
use relay_common::time::UnixTimestamp;
use relay_conventions::attributes::*;
use relay_conventions::{AttributeInfo, ReplacementName, WriteBehavior};
use relay_event_schema::protocol::{
    Attribute, AttributeType, Attributes, BrowserContext, Geo, SpanV2, SpanV2Status,
};
use relay_protocol::{Annotated, Empty, Error, ErrorKind, Meta, Object, Remark, RemarkType, Value};
use relay_sampling::DynamicSamplingContext;
use relay_spans::{derive_description_for_v2_span, derive_op_for_v2_span};

use crate::span::TABLE_NAME_REGEX;
use crate::span::country_subregion::Subregion;
use crate::span::description::{scrub_db_query, scrub_http};
use crate::span::tag_extraction::{
    domain_from_scrubbed_http, domain_from_server_address, span_op_to_category,
    sql_action_from_query, sql_tables_from_query,
};
use crate::{
    ClientHints, FromUserAgentInfo as _, RawUserAgentInfo, TransactionNameRule,
    normalize_transaction_name,
};

mod ai;
mod attribute_like;
mod mobile;
mod size;
pub mod time;
pub mod trace_metric;
mod trimming;

pub use self::ai::normalize_ai;
pub use self::attribute_like::AttributesLike;
pub use self::mobile::{normalize_mobile_attributes, normalize_mobile_measurements};
pub use self::size::*;
pub use self::trimming::TrimmingProcessor;

/// How an EAP item entered Relay.
#[derive(Debug, Clone)]
pub enum Ingress {
    /// The item comes from an integration (e.g. OTEL, Vercel).
    Integration,
    /// The item comes from an item container.
    Container,
    /// The item was converted from a legacy item type.
    Legacy,
}

impl fmt::Display for Ingress {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Ingress::Integration => f.write_str("integration"),
            Ingress::Container => f.write_str("container"),
            Ingress::Legacy => f.write_str("legacy"),
        }
    }
}

/// The pipeline through which an item went in Relay.
#[derive(Debug, Clone)]
pub enum Pipeline {
    /// The legacy standalone span pipeline.
    SpanLegacy,
    /// The legacy transaction pipeline.
    Transaction,
    /// The V2 span pipeline.
    SpanV2,
}

impl fmt::Display for Pipeline {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Pipeline::SpanLegacy => f.write_str("span_legacy"),
            Pipeline::Transaction => f.write_str("transaction"),
            Pipeline::SpanV2 => f.write_str("span_v2"),
        }
    }
}

/// Writes `ingress` and `pipeline` into [`SENTRY__RELAY__INGRESS`] and
/// [`SENTRY__RELAY__PIPELINE`], respectively.
pub fn normalize_pipeline_attributes(
    attributes: &mut Annotated<Attributes>,
    ingress: Option<&Ingress>,
    pipeline: Option<&Pipeline>,
) {
    let attributes = attributes.get_or_insert_with(Default::default);

    if let Some(ingress) = ingress {
        attributes.insert_if_missing(SENTRY__RELAY__INGRESS, || ingress.to_string());
    }

    if let Some(pipeline) = pipeline {
        attributes.insert_if_missing(SENTRY__RELAY__PIPELINE, || pipeline.to_string());
    }
}

/// Infers the sentry.op attribute and inserts it into [`Attributes`] if not already set.
pub fn normalize_sentry_op(attributes: &mut Annotated<Attributes>) {
    if attributes
        .value()
        .is_some_and(|attrs| attrs.contains_key(SENTRY__OP))
    {
        return;
    }
    let inferred_op = derive_op_for_v2_span(attributes);
    let attrs = attributes.get_or_insert_with(Default::default);
    attrs.insert_if_missing(SENTRY__OP, || inferred_op);
}

/// Normalizes a V2 span's [`SENTRY__DESCRIPTION`] attribute.
///
/// If the span has no description, this will attempt to synthesize one from its
/// attributes using [derive_description_for_v2_span].
pub fn normalize_sentry_description(
    attributes: &mut Annotated<Attributes>,
    name: &Annotated<String>,
) {
    let Some(attributes) = attributes.value_mut() else {
        return;
    };

    let description = attributes.get_annotated_value(SENTRY__DESCRIPTION);

    if description.is_some_and(|d| !d.is_empty()) {
        return;
    }

    if let Some(description) = derive_description_for_v2_span(attributes, name) {
        attributes.insert(SENTRY__DESCRIPTION, description);
    }
}

/// Normalizes a V2 span's name.
///
/// If the span has no name, this will attempt to synthesize one from its
/// attributes using [relay_spans::name_for_attributes].
///
/// This is only relevant for spans converted from V1. Spans that were sent
/// as V2 should always have a name.
pub fn normalize_span_name(span: &mut SpanV2) {
    if span.name.value().is_some() {
        return;
    }

    let Some(attributes) = span.attributes.value() else {
        return;
    };

    if let Some(name) = relay_spans::name_for_attributes(attributes) {
        span.name = name.into();
    }
}

/// Infers the sentry.category attribute and inserts it into `attributes` if not
/// already set.  The category is derived from the span operation or other span
/// attributes.
pub fn normalize_span_category(attributes: &mut Annotated<Attributes>) {
    let Some(attributes_val) = attributes.value() else {
        return;
    };

    // Clients can explicitly set the category.
    if attribute_is_nonempty_string(attributes_val, SENTRY__CATEGORY) {
        return;
    }

    // Try to derive category from sentry.op.
    if let Some(op_value) = attributes_val.get_value(SENTRY__OP)
        && let Some(op_str) = op_value.as_str()
    {
        let op_lowercase = op_str.to_lowercase();
        if let Some(category) = span_op_to_category(&op_lowercase) {
            let attrs = attributes.get_or_insert_with(Default::default);
            attrs.insert(SENTRY__CATEGORY, category.to_owned());
            return;
        }
    }

    // Without an op, rely on attributes typically found only on spans of the given category.
    let category = if attribute_is_nonempty_string(attributes_val, DB__SYSTEM__NAME) {
        Some("db")
    } else if attribute_is_nonempty_string(attributes_val, HTTP__REQUEST__METHOD) {
        Some("http")
    } else if attribute_is_nonempty_string(attributes_val, UI__COMPONENT_NAME) {
        Some("ui")
    } else if attribute_is_nonempty_string(attributes_val, RESOURCE__RENDER_BLOCKING_STATUS) {
        Some("resource")
    } else if attributes_val
        .get_value(SENTRY__ORIGIN)
        .and_then(|v| v.as_str())
        .is_some_and(|v| v == "auto.ui.browser.metrics")
    {
        Some("browser")
    } else {
        None
    };

    // Write the derived category to attributes
    if let Some(category) = category {
        let attrs = attributes.get_or_insert_with(Default::default);
        attrs.insert(SENTRY__CATEGORY, category.to_owned());
    }
}

fn attribute_is_nonempty_string(attributes: &Attributes, key: &str) -> bool {
    attributes
        .get_value(key)
        .and_then(|v| v.as_str())
        .is_some_and(|s| !s.is_empty())
}

/// Normalizes/validates all attribute types.
///
/// Removes and marks all attributes with an error for which the specified [`AttributeType`]
/// does not match the value.
pub fn normalize_attribute_types(attributes: &mut Annotated<Attributes>) {
    let Some(attributes) = attributes.value_mut() else {
        return;
    };

    let attributes = attributes.0.values_mut();
    for attribute in attributes {
        use AttributeType::*;

        let Some(inner) = attribute.value_mut() else {
            continue;
        };

        match (&mut inner.value.ty, &mut inner.value.value) {
            (Annotated(Some(Boolean), _), Annotated(Some(Value::Bool(_)), _)) => (),
            (Annotated(Some(Integer), _), Annotated(Some(Value::I64(_)), _)) => (),
            (Annotated(Some(Integer), _), Annotated(Some(Value::U64(u)), _))
                if i64::try_from(*u).is_ok() => {}
            (Annotated(Some(Double), _), Annotated(Some(Value::I64(_)), _)) => (),
            (Annotated(Some(Double), _), Annotated(Some(Value::U64(_)), _)) => (),
            (Annotated(Some(Double), _), Annotated(Some(Value::F64(_)), _)) => (),
            (Annotated(Some(String), _), Annotated(Some(Value::String(_)), _)) => (),
            (Annotated(Some(Array), _), Annotated(Some(Value::Array(arr)), _)) => {
                if !is_supported_array(arr) {
                    let _ = attribute.value_mut().take();
                    attribute.meta_mut().add_error(ErrorKind::InvalidData);
                }
            }
            // Note: currently the mapping to Kafka requires that invalid or unknown combinations
            // of types and values are removed from the mapping.
            //
            // Usually Relay would only modify the offending values, but for now, until there
            // is better support in the pipeline here, we need to remove the entire attribute.
            (Annotated(Some(Unknown(_)), _), _) => {
                let original = attribute.value_mut().take();
                attribute.meta_mut().add_error(ErrorKind::InvalidData);
                attribute.meta_mut().set_original_value(original);
            }
            (Annotated(Some(_), _), Annotated(Some(_), _)) => {
                let original = attribute.value_mut().take();
                attribute.meta_mut().add_error(ErrorKind::InvalidData);
                attribute.meta_mut().set_original_value(original);
            }
            (Annotated(None, _), _) | (_, Annotated(None, _)) => {
                let original = attribute.value_mut().take();
                attribute.meta_mut().add_error(ErrorKind::MissingAttribute);
                attribute.meta_mut().set_original_value(original);
            }
        }
    }
}

/// Returns `true` if the passed array is an array we currently support.
///
/// Currently all arrays must be homogeneous types.
fn is_supported_array(arr: &[Annotated<Value>]) -> bool {
    let mut iter = arr.iter();

    let Some(first) = iter.next() else {
        // Empty arrays are supported.
        return true;
    };

    let item = iter.try_fold(first, |prev, current| {
        let r = match (prev.value(), current.value()) {
            (None, None) => prev,
            (None, Some(_)) => current,
            (Some(_), None) => prev,
            (Some(Value::String(_)), Some(Value::String(_))) => prev,
            (Some(Value::Bool(_)), Some(Value::Bool(_))) => prev,
            (
                // We allow mixing different numeric types because they are all the same in JSON.
                Some(Value::I64(_) | Value::U64(_) | Value::F64(_)),
                Some(Value::I64(_) | Value::U64(_) | Value::F64(_)),
            ) => prev,
            // Everything else is unsupported.
            //
            // This includes nested arrays, nested objects and mixed arrays for now.
            (Some(_), Some(_)) => return None,
        };

        Some(r)
    });

    let Some(item) = item else {
        // Unsupported combination of types.
        return false;
    };

    matches!(
        item.value(),
        // `None` -> `[null, null]` is allowed, as the `Annotated` may carry information.
        // `Some` -> must be a currently supported type.
        None | Some(
            Value::String(_) | Value::Bool(_) | Value::I64(_) | Value::U64(_) | Value::F64(_)
        )
    )
}

/// Adds the `received` time to the attributes.
pub fn normalize_received(attributes: &mut Annotated<Attributes>, received: DateTime<Utc>) {
    attributes
        .get_or_insert_with(Default::default)
        .insert_if_missing(SENTRY__OBSERVED_TIMESTAMP_NANOS, || {
            received
                .timestamp_nanos_opt()
                .unwrap_or_else(|| UnixTimestamp::now().as_nanos() as i64)
                .to_string()
        });
}

/// Client user agent information.
///
/// This is information which is extracted from the client's request.
#[derive(Debug, Copy, Clone, Default)]
pub struct ClientUserAgentInfo<'a> {
    /// The user agent extracted from the client request.
    pub user_agent: Option<&'a str>,
    /// Client hints extracted from the client request.
    pub hints: ClientHints<&'a str>,
}

/// Normalizes the user agent/client information into [`Attributes`].
///
/// Does not modify the attributes if there is already browser information present,
/// to preserve original values.
///
/// The `client_info` should be omitted for cases where the info is unreliable or incorrect, for
/// example when the client is a backend SDK or another Relay.
pub fn normalize_user_agent(
    attributes: &mut Annotated<Attributes>,
    client_info: Option<ClientUserAgentInfo<'_>>,
) {
    let attributes = attributes.get_or_insert_with(Default::default);

    if attributes.contains_key(BROWSER__NAME) || attributes.contains_key(BROWSER__VERSION) {
        return;
    }

    // Prefer the stored/explicitly sent user agent over the user agent from the client/transport.
    if let Some(ua) = client_info.and_then(|ci| ci.user_agent) {
        attributes.insert_if_missing(USER_AGENT__ORIGINAL, || ua.to_owned());
    }

    let user_agent = attributes
        .get_value(USER_AGENT__ORIGINAL)
        .and_then(|v| v.as_str());

    let Some(context) = BrowserContext::from_hints_or_ua(&RawUserAgentInfo {
        user_agent,
        client_hints: client_info.map(|ci| ci.hints).unwrap_or_default(),
    }) else {
        return;
    };

    attributes.insert_if_missing(BROWSER__NAME, || context.name);
    attributes.insert_if_missing(BROWSER__VERSION, || context.version);
}

/// Normalizes the client address into [`Attributes`].
///
/// Infers the client ip from the client information which was provided to Relay, if the SDK
/// indicates the client ip should be inferred by setting it to `{{auto}}`.
///
/// This requires cooperation from SDKs as inferring a client ip only works in non-server
/// environments, where the user/client device is also the device sending the item.
pub fn normalize_client_address(attributes: &mut Annotated<Attributes>, client_ip: Option<IpAddr>) {
    let Some(attributes) = attributes.value_mut() else {
        return;
    };

    let client_address = attributes
        .get_value(CLIENT__ADDRESS)
        .and_then(|v| v.as_str());

    if client_address == Some("{{auto}}") {
        match client_ip {
            Some(client_ip) => attributes.insert(CLIENT__ADDRESS, client_ip.to_string()),
            None => drop(attributes.remove(CLIENT__ADDRESS)),
        }
    }
}

/// Injects a client ip address into [`Attributes`].
///
/// Unlike [`normalize_client_address`], this always injects the passed client ip into `attributes`.
pub fn normalize_inject_client_address(
    attributes: &mut Annotated<Attributes>,
    client_ip: Option<IpAddr>,
) {
    let Some(client_ip) = client_ip else {
        return;
    };

    let attributes = attributes.get_or_insert_with(Default::default);
    attributes.insert_if_missing(CLIENT__ADDRESS, || client_ip.to_string());
}

/// Normalizes the user's geographical information into [`Attributes`].
///
/// Does not modify the attributes if there is already user geo information present,
/// to preserve original values.
///
/// This uses the [`CLIENT__ADDRESS`] attribute to infer the client IP address, you may want to run
/// [`normalize_client_address`] before [`normalize_user_geo`].
pub fn normalize_user_geo(
    attributes: &mut Annotated<Attributes>,
    info: impl FnOnce(IpAddr) -> Option<Geo>,
) {
    let Some(attributes) = attributes.value_mut() else {
        return;
    };

    if [
        USER__GEO__COUNTRY_CODE,
        USER__GEO__CITY,
        USER__GEO__SUBDIVISION,
        USER__GEO__REGION,
    ]
    .into_iter()
    .any(|a| attributes.contains_key(a))
    {
        return;
    }

    let client_address = attributes
        .get_value(CLIENT__ADDRESS)
        .and_then(|v| v.as_str())
        .and_then(|v| v.parse().ok());

    let Some(geo) = client_address.and_then(info) else {
        return;
    };

    let subregion = geo
        .country_code
        .value()
        .and_then(|cc| Subregion::from_iso2(cc));

    attributes.insert_if_missing(USER__GEO__COUNTRY_CODE, || geo.country_code);
    attributes.insert_if_missing(USER__GEO__CITY, || geo.city);
    attributes.insert_if_missing(USER__GEO__SUBDIVISION, || geo.subdivision);
    attributes.insert_if_missing(USER__GEO__REGION, || geo.region);
    if let Some(subregion) = subregion {
        attributes.insert_if_missing(USER__GEO__SUBREGION, || (subregion as u8).to_string());
    }
}

/// Normalizes the dynamic sampling context into [`Attributes`].
///
/// If `is_segment` is set to `false`, the function will only add select attributes that are
/// necessary on every span - both segment and non-segment - for dynamic sampling to work. More
/// attributes are added when `is_segment` is set to `true`.
pub fn normalize_dsc(
    attributes: &mut Annotated<Attributes>,
    is_segment: &Annotated<bool>,
    dsc: Option<&DynamicSamplingContext>,
) {
    let Some(dsc) = dsc else {
        return;
    };

    let attributes = attributes.get_or_insert_with(Default::default);

    attributes.insert(SENTRY__DSC__TRACE_ID, dsc.trace_id.to_string());

    match &dsc.transaction {
        Some(transaction) => attributes.insert(SENTRY__DSC__TRANSACTION, transaction.clone()),
        None => drop(attributes.remove(SENTRY__DSC__TRANSACTION)),
    }

    if let Some(project_id) = &dsc.project_id {
        attributes.insert(SENTRY__DSC__PROJECT_ID, project_id.to_string());
    }

    if is_segment.value().is_some_and(|is_segment| *is_segment) {
        attributes.insert(SENTRY__DSC__PUBLIC_KEY, dsc.public_key.to_string());
        if let Some(release) = &dsc.release {
            attributes.insert(SENTRY__DSC__RELEASE, release.clone());
        }
        if let Some(environment) = &dsc.environment {
            attributes.insert(SENTRY__DSC__ENVIRONMENT, environment.clone());
        }
        if let Some(sample_rate) = dsc.sample_rate {
            attributes.insert(SENTRY__DSC__SAMPLE_RATE, sample_rate);
        }
        if let Some(sampled) = dsc.sampled {
            attributes.insert(SENTRY__DSC__SAMPLED, sampled);
        }
    }
}

/// Sets the `sentry.trace.status` attribute on segment spans.
///
/// The value is derived from the `sentry.status` attribute if present, falling back to the span's
/// top-level `status` field.
pub fn normalize_trace_status(
    attributes: &mut Annotated<Attributes>,
    is_segment: &Annotated<bool>,
    status: &Annotated<SpanV2Status>,
) {
    if is_segment.value().is_none_or(|is_segment| !*is_segment) {
        return;
    }

    let attributes = attributes.get_or_insert_with(Default::default);
    if attributes.contains_key(SENTRY__TRACE__STATUS) {
        return;
    }

    let trace_status = attributes
        .get_value(SENTRY__STATUS)
        .and_then(|v| v.as_str())
        .map(|s| s.to_owned())
        .or_else(|| status.value().map(|s| s.to_string()));

    if let Some(trace_status) = trace_status {
        attributes.insert(SENTRY__TRACE__STATUS, trace_status);
    }
}

/// Normalizes the client sample rate attribute to be in the range `(0, 1]`.
///
/// If the attribute is missing, it is created from the DSC sample rate, falling back to `1.0`. The
/// resulting value is validated the same way as a client supplied one.
///
/// This is only relevant for spans as other eap types re not sampled.
pub fn normalize_client_sample_rate(
    attributes: &mut Annotated<Attributes>,
    dsc_sample_rate: Option<f64>,
) {
    let attributes = attributes.get_or_insert_with(Default::default);

    if attributes.get_value(SENTRY__CLIENT_SAMPLE_RATE).is_none() {
        attributes.insert(SENTRY__CLIENT_SAMPLE_RATE, dsc_sample_rate.unwrap_or(1.0));
    }

    // This is fine if normalizations like this stay one-offs. If at some point we end up with more
    // of these structural validations or normalizations based on attributes, they should be
    // outsourced to conventions and enforced with a dedicated processor.
    fn normalize_sample_rate(sr: &Annotated<Attribute>) -> Option<Annotated<Attribute>> {
        match sr.value()?.value.value.value()?.as_f64() {
            Some(v) if v > 0.0 && v <= 1.0 => None,
            // This is an invalid sample rate, either by type or value.
            _ => Some(Annotated::from_error(
                Error::expected("sample rate > 0.0, <= 1.0"),
                None,
            )),
        }
    }

    if let Some(sr) = attributes.0.get_mut(SENTRY__CLIENT_SAMPLE_RATE)
        && let Some(new_sr) = normalize_sample_rate(sr)
    {
        *sr = new_sr;
    }
}

/// Validates the [`SENTRY__RELEASE`] attribute.
///
/// Invalid releases are removed and marked with an error, the same way releases are validated on
/// events.
pub fn normalize_release(attributes: &mut Annotated<Attributes>) {
    let Some(release) = attributes
        .value_mut()
        .as_mut()
        .and_then(|attributes| attributes.0.get_mut(SENTRY__RELEASE))
    else {
        return;
    };

    if let Some(Value::String(value)) = release.value().and_then(|r| r.value.value.value())
        && crate::validate_release(value).is_err()
    {
        let original = release.value_mut().take();
        release.meta_mut().add_error(ErrorKind::InvalidData);
        release.meta_mut().set_original_value(original);
    }
}

/// Normalizes deprecated attributes according to `sentry-conventions`.
///
/// Attributes with a status of `"normalize"` will be moved to their replacement name.
/// If there is already a value present under the replacement name, it will be left alone,
/// but the deprecated attribute is removed anyway.
///
/// Attributes with a status of `"backfill"` will be copied to their replacement name if the
/// replacement name is not present. In any case, the original name is left alone.
pub fn normalize_attribute_names(attributes: &mut Annotated<impl AttributesLike>) {
    let Some(attributes) = attributes.value_mut() else {
        return;
    };

    normalize_attribute_names_inner(
        attributes.as_object_mut(),
        relay_conventions::attribute_info_with_fragment,
    )
}

type AttributeInfoFn = fn(&str) -> Option<(&'static AttributeInfo, Option<&str>)>;

fn normalize_attribute_names_inner<T>(attributes: &mut Object<T>, attribute_info: AttributeInfoFn)
where
    T: Clone,
{
    let attribute_names: Vec<_> = attributes.keys().cloned().collect();

    for name in attribute_names {
        let Some((attribute_info, fragment)) = attribute_info(&name) else {
            continue;
        };

        match attribute_info.write_behavior {
            WriteBehavior::CurrentName => continue,
            WriteBehavior::NewName(new_name) => {
                let Some(old_attribute) = attributes.get_mut(&name) else {
                    continue;
                };

                let Some(new_name) = resolve_attribute_name(new_name, fragment) else {
                    relay_log::error!(
                        attribute = name,
                        ?fragment,
                        "Attribute placeholder mismatch"
                    );
                    continue;
                };

                let mut meta = Meta::default();
                // TODO: Possibly add a new RemarkType for "renamed/moved"
                meta.add_remark(Remark::new(RemarkType::Removed, "attribute.deprecated"));
                let new_attribute = std::mem::replace(old_attribute, Annotated(None, meta));

                if !attributes.contains_key(&*new_name) {
                    attributes.insert(new_name.into_owned(), new_attribute);
                }
            }
            WriteBehavior::BothNames(new_name) => {
                let Some(new_name) = resolve_attribute_name(new_name, fragment) else {
                    relay_log::error!(
                        attribute = name,
                        ?fragment,
                        "Attribute placeholder mismatch"
                    );
                    continue;
                };

                if !attributes.contains_key(&*new_name)
                    && let Some(current_attribute) = attributes.get(&name).cloned()
                {
                    attributes.insert(new_name.into_owned(), current_attribute);
                }
            }
        }
    }
}

/// Resolves the name of a replacement attribute for rewriting.
///
/// There are two cases to consider:
/// - `name` is `Static` and `fragment` is `None`: This means that both
///   the source and target attribute don't have a placeholder.
/// - `name` is `Dynamic` and `fragment` is `Some`: This means that both the
///   source and target attribute do have a placeholder.
fn resolve_attribute_name(
    name: ReplacementName,
    fragment: Option<&str>,
) -> Option<Cow<'static, str>> {
    match (name, fragment) {
        // Neither the original nor the replacement attribute contains a placeholder.
        // Simply use the replacement attribute's static name.
        (ReplacementName::Static(name), None) => Some(Cow::Borrowed(name)),
        // Both the original and replacement attribute contain a placeholder.
        // Use the replacement's interpolation function and the matched fragment
        // to obtain the new name.
        (ReplacementName::Dynamic(name_fn), Some(fragment)) => Some(Cow::Owned(name_fn(fragment))),
        // The other cases would mean that either the original attribute contains a placeholder
        // and the replacement doesn't, or vice versa. This is ruled out by a compile-time check
        // in `relay-conventions`.
        _ => None,
    }
}

/// Normalizes the values of a set of attributes if present in the span.
///
/// Each span type has a set of important attributes containing the main relevant information displayed
/// in the product-end. For instance, for DB spans, these attributes are `db.query.text`, `db.operation.name`,
/// `db.collection.name`. Previously, V1 spans always held these important values in the `description` field,
/// however, V2 spans now store these values in their respective attributes based on sentry conventions.
/// This function ports over the SpanV1 normalization logic that was previously in `scrub_span_description`
/// by creating a set of functions to handle each group of attributes separately.
pub fn normalize_attribute_values(
    attributes: &mut Annotated<Attributes>,
    http_span_allowed_hosts: &[String],
) {
    normalize_db_attributes(attributes);
    normalize_http_attributes(attributes, http_span_allowed_hosts);
    normalize_mobile_attributes(attributes);
}

/// Normalizes the following db attributes: `db.query.text`, `db.operation.name`, `db.collection.name`
/// based on related attributes within DB spans.
///
/// This function reads the raw db query from `db.query.text`, scrubs it if possible, and writes
/// the normalized query to the `sentry.normalized_db_query` attribute. After normalizing the query,
/// the db operation and collection name are updated if needed.
///
/// Note: This function assumes that the sentry.op has already been inferred and set in the attributes.
fn normalize_db_attributes(annotated_attributes: &mut Annotated<Attributes>) {
    let Some(attributes) = annotated_attributes.value() else {
        return;
    };

    // Skip normalization if the normalized db query attribute is already set.
    if attributes.get_value(SENTRY__NORMALIZED_DB_QUERY).is_some() {
        return;
    }

    let (op, sub_op) = attributes
        .get_value(SENTRY__OP)
        .and_then(|v| v.as_str())
        .map(|op| op.split_once('.').unwrap_or((op, "")))
        .unwrap_or_default();

    let raw_query = attributes
        .get_value(DB__QUERY__TEXT)
        .or_else(|| {
            if op == "db" {
                attributes.get_value(SENTRY__DESCRIPTION)
            } else {
                None
            }
        })
        .and_then(|v| v.as_str());

    let db_system = attributes
        .get_value(DB__SYSTEM__NAME)
        .and_then(|v| v.as_str());

    let db_operation = attributes
        .get_value(DB__OPERATION__NAME)
        .and_then(|v| v.as_str());

    let collection_name = attributes
        .get_value(DB__COLLECTION__NAME)
        .and_then(|v| v.as_str());

    let span_origin = attributes
        .get_value(SENTRY__ORIGIN)
        .and_then(|v| v.as_str());

    let (normalized_db_query, parsed_sql) = if let Some(raw_query) = raw_query {
        scrub_db_query(
            raw_query,
            sub_op,
            db_system,
            db_operation,
            collection_name,
            span_origin,
        )
    } else {
        (None, None)
    };

    let db_operation = if db_operation.is_none() {
        if sub_op == "redis" || db_system == Some("redis") {
            // This only works as long as redis span descriptions contain the command + " *"
            if let Some(query) = normalized_db_query.as_ref() {
                let command = query.replace(" *", "");
                if command.is_empty() {
                    None
                } else {
                    Some(command)
                }
            } else {
                None
            }
        } else if let Some(raw_query) = raw_query {
            // For other database operations, try to get the operation from data
            sql_action_from_query(raw_query).map(|a| a.to_uppercase())
        } else {
            None
        }
    } else {
        db_operation.map(|db_operation| db_operation.to_uppercase())
    };

    let db_collection_name: Option<String> = if let Some(name) = collection_name {
        if db_system == Some("mongodb") {
            match TABLE_NAME_REGEX.replace_all(name, "{%s}") {
                Cow::Owned(s) => Some(s),
                Cow::Borrowed(_) => Some(name.to_owned()),
            }
        } else {
            Some(name.to_owned())
        }
    } else if span_origin == Some("auto.db.supabase") {
        normalized_db_query
            .as_ref()
            .and_then(|query| query.strip_prefix("from("))
            .and_then(|s| s.strip_suffix(")"))
            .map(String::from)
    } else if let Some(raw_query) = raw_query {
        sql_tables_from_query(raw_query, &parsed_sql)
    } else {
        None
    };

    if let Some(attributes) = annotated_attributes.value_mut() {
        if let Some(normalized_db_query) = normalized_db_query {
            let mut normalized_db_query_hash = format!("{:x}", md5::compute(&normalized_db_query));
            normalized_db_query_hash.truncate(16);

            attributes.insert(SENTRY__NORMALIZED_DB_QUERY, normalized_db_query);
            attributes.insert(SENTRY__NORMALIZED_DB_QUERY__HASH, normalized_db_query_hash);
        }
        if let Some(db_operation_name) = db_operation {
            attributes.insert(DB__OPERATION__NAME, db_operation_name)
        }
        if let Some(db_collection_name) = db_collection_name {
            attributes.insert(DB__COLLECTION__NAME, db_collection_name);
        }
    }
}

/// Normalizes the following http attributes: `http.request.method` and `server.address`.
///
/// The normalization process first scrubs the url and extracts the server address from the url.
/// It also sets 'url.full' to the raw url if it is not already set and can be retrieved from the server address.
fn normalize_http_attributes(
    annotated_attributes: &mut Annotated<Attributes>,
    allowed_hosts: &[String],
) {
    let Some(attributes) = annotated_attributes.value() else {
        return;
    };

    // Skip normalization if not an http span.
    if attributes
        .get_value(SENTRY__CATEGORY)
        .is_none_or(|category| category.as_str().unwrap_or_default() != "http")
    {
        return;
    }

    let op = attributes.get_value(SENTRY__OP).and_then(|v| v.as_str());

    let (description_method, description_url) = match attributes
        .get_value(SENTRY__DESCRIPTION)
        .and_then(|v| v.as_str())
        .and_then(|description| description.split_once(' '))
    {
        Some((method, url)) => (Some(method), Some(url)),
        _ => (None, None),
    };

    let method = attributes
        .get_value(HTTP__REQUEST__METHOD)
        .and_then(|v| v.as_str())
        .or(description_method);

    let server_address = attributes
        .get_value(SERVER__ADDRESS)
        .and_then(|v| v.as_str());

    let url: Option<&str> = attributes
        .get_value(URL__FULL)
        .and_then(|v| v.as_str())
        .or(description_url);
    let url_scheme = attributes.get_value(URL__SCHEME).and_then(|v| v.as_str());

    // If the span op is "http.client" and the method and url are present,
    // extract a normalized domain to be stored in the "server.address" attribute.
    let (normalized_server_address, raw_url) = if op == Some("http.client") {
        let domain_from_scrubbed_http = method
            .zip(url)
            .and_then(|(method, url)| scrub_http(method, url, allowed_hosts))
            .and_then(|scrubbed_http| domain_from_scrubbed_http(&scrubbed_http));

        if let Some(domain) = domain_from_scrubbed_http {
            (Some(domain), url.map(String::from))
        } else {
            domain_from_server_address(server_address, url_scheme)
        }
    } else {
        (None, None)
    };

    let method = method.map(|m| m.to_uppercase());

    if let Some(attributes) = annotated_attributes.value_mut() {
        if let Some(method) = method {
            attributes.insert(HTTP__REQUEST__METHOD, method);
        }

        if let Some(normalized_server_address) = normalized_server_address {
            attributes.insert(SERVER__ADDRESS, normalized_server_address);
        }

        if let Some(raw_url) = raw_url {
            attributes.insert_if_missing(URL__FULL, || raw_url);
        }
    }
}

/// Makes sure web vital spans are not identified with segments.
///
/// This was ported from the legacy pipeline for behavior parity.
/// At some point in the future, web vital spans will become metrics,
/// and this will become academic.
pub fn normalize_web_vital_span_segment(span: &mut SpanV2) {
    let Some(attributes) = span.attributes.value_mut() else {
        return;
    };

    if let Some(op) = attributes.get_value(SENTRY__OP)
        && let Some(op_name) = op.as_str()
        && (op_name.starts_with("ui.interaction.") || op_name.starts_with("ui.webvital."))
    {
        span.is_segment = None.into();
        span.parent_span_id = None.into();
        attributes.remove(SENTRY__SEGMENT__ID);
    }
}

/// Normalize the [`SENTRY__SEGMENT__NAME`] attribute (aka the transaction)
/// by running [`normalize_transaction_name`] on it.
///
/// This exists for parity with the legacy standalone span pipeline.
pub fn normalize_segment_name(
    attributes: &mut Annotated<Attributes>,
    tx_name_rules: &[TransactionNameRule],
) {
    let Some(attributes) = attributes.value_mut() else {
        return;
    };

    let Some(attr_value) = attributes.get_annotated_value_mut(SENTRY__SEGMENT__NAME) else {
        return;
    };

    let mut segment_name = match &attr_value.0 {
        Some(Value::String(s)) => Annotated(Some(s.to_owned()), attr_value.1.clone()),
        _ => return,
    };

    normalize_transaction_name(&mut segment_name, tx_name_rules);

    *attr_value = segment_name.map_value(Value::String);
}

/// Double writes sentry conventions attributes into legacy attributes.
///
/// This achieves backwards compatibility as it allows products to continue using legacy attributes
/// while we accumulate spans that conform to sentry conventions.
///
/// This function is called after attribute value normalization (`normalize_attribute_values`) as it
/// clones normalized attributes into legacy attributes.
pub fn write_legacy_attributes(attributes: &mut Annotated<Attributes>) {
    let Some(attributes) = attributes.value_mut() else {
        return;
    };

    // Map of new sentry conventions attributes to legacy SpanV1 attributes
    let current_to_legacy_attributes = [
        // DB attributes
        (SENTRY__NORMALIZED_DB_QUERY, SENTRY__NORMALIZED_DESCRIPTION),
        (SENTRY__NORMALIZED_DB_QUERY__HASH, SENTRY__GROUP),
        (DB__OPERATION__NAME, SENTRY__ACTION),
        // HTTP attributes
        (SERVER__ADDRESS, SENTRY__DOMAIN),
        (HTTP__REQUEST__METHOD, SENTRY__ACTION),
        (HTTP__RESPONSE__STATUS_CODE, SENTRY__STATUS_CODE),
    ];

    for (current_attribute, legacy_attribute) in current_to_legacy_attributes {
        if attributes.contains_key(legacy_attribute) {
            continue;
        }

        let Some(attr) = attributes.get_attribute(current_attribute) else {
            continue;
        };

        attributes.insert(legacy_attribute, attr.value.clone());
    }

    if !attributes.contains_key(SENTRY__DOMAIN)
        && let Some(db_domain) = attributes
            .get_value(DB__COLLECTION__NAME)
            .and_then(|value| value.as_str())
            .map(|collection_name| collection_name.to_owned())
    {
        // sentry.domain must be wrapped in preceding and trailing commas, for old hacky reasons.
        attributes.insert(
            SENTRY__DOMAIN,
            match (db_domain.starts_with(','), db_domain.ends_with(',')) {
                (true, true) => db_domain,
                (true, false) => format!("{db_domain},"),
                (false, true) => format!(",{db_domain}"),
                (false, false) => format!(",{db_domain},"),
            },
        );
    }
}

#[cfg(test)]
mod tests {
    use std::time::Duration;

    use relay_base_schema::project::ProjectId;
    use relay_protocol::{Empty, SerializableAnnotated, assert_annotated_snapshot};
    use relay_sampling::DynamicSamplingContext;

    use super::*;

    fn mock_dsc(transaction: Option<&str>) -> DynamicSamplingContext {
        DynamicSamplingContext {
            trace_id: "67e5504410b1426f9247bb680e5fe0c8".parse().unwrap(),
            public_key: "12345678901234567890123456789012".parse().unwrap(),
            project_id: Some(ProjectId::new(42)),
            release: None,
            environment: None,
            transaction: transaction.map(str::to_owned),
            sample_rate: None,
            user: Default::default(),
            replay_id: None,
            sampled: None,
            other: Default::default(),
        }
    }

    #[test]
    fn test_normalize_dsc_child_span_no_dsc() {
        let mut attributes = Annotated::empty();
        normalize_dsc(&mut attributes, &Annotated::new(false), None);
        assert!(attributes.value().is_none());
    }

    #[test]
    fn test_normalize_dsc_child_span_no_transaction() {
        let mut attributes = Annotated::empty();
        let dsc = &mock_dsc(None);
        normalize_dsc(&mut attributes, &Annotated::new(false), Some(dsc));
        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.dsc.project_id": {
            "type": "string",
            "value": "42"
          },
          "sentry.dsc.trace_id": {
            "type": "string",
            "value": "67e5504410b1426f9247bb680e5fe0c8"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_dsc_child_span() {
        let mut attributes = Annotated::empty();
        let dsc = &mock_dsc(Some("/some/endpoint"));
        normalize_dsc(&mut attributes, &Annotated::new(false), Some(dsc));
        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.dsc.project_id": {
            "type": "string",
            "value": "42"
          },
          "sentry.dsc.trace_id": {
            "type": "string",
            "value": "67e5504410b1426f9247bb680e5fe0c8"
          },
          "sentry.dsc.transaction": {
            "type": "string",
            "value": "/some/endpoint"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_dsc_segment() {
        let mut attributes = Annotated::empty();
        let dsc = &mock_dsc(Some("/some/endpoint"));
        normalize_dsc(&mut attributes, &Annotated::new(true), Some(dsc));
        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.dsc.project_id": {
            "type": "string",
            "value": "42"
          },
          "sentry.dsc.public_key": {
            "type": "string",
            "value": "12345678901234567890123456789012"
          },
          "sentry.dsc.trace_id": {
            "type": "string",
            "value": "67e5504410b1426f9247bb680e5fe0c8"
          },
          "sentry.dsc.transaction": {
            "type": "string",
            "value": "/some/endpoint"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_trace_status_not_segment() {
        let mut attributes = Annotated::empty();
        normalize_trace_status(
            &mut attributes,
            &Annotated::new(false),
            &Annotated::new(SpanV2Status::Ok),
        );
        assert!(attributes.value().is_none());
    }

    #[test]
    fn test_normalize_trace_status_already_set() {
        let mut attributes = Annotated::from_json(
            r#"{"sentry.trace.status": {"type": "string", "value": "internal_error"}}"#,
        )
        .unwrap();
        normalize_trace_status(
            &mut attributes,
            &Annotated::new(true),
            &Annotated::new(SpanV2Status::Error),
        );
        assert_eq!(
            attributes
                .value()
                .unwrap()
                .get_value("sentry.trace.status")
                .and_then(|v| v.as_str()),
            Some("internal_error"),
        );
    }

    #[test]
    fn test_normalize_trace_status_from_sentry_status_attribute() {
        let mut attributes = Annotated::from_json(
            r#"{"sentry.status": {"type": "string", "value": "internal_error"}}"#,
        )
        .unwrap();
        normalize_trace_status(
            &mut attributes,
            &Annotated::new(true),
            &Annotated::new(SpanV2Status::Error),
        );
        assert_eq!(
            attributes
                .value()
                .unwrap()
                .get_value("sentry.trace.status")
                .and_then(|v| v.as_str()),
            Some("internal_error"),
        );
    }

    #[test]
    fn test_normalize_trace_status_from_span_status() {
        let mut attributes = Annotated::empty();
        normalize_trace_status(
            &mut attributes,
            &Annotated::new(true),
            &Annotated::new(SpanV2Status::Error),
        );
        assert_eq!(
            attributes
                .value()
                .unwrap()
                .get_value("sentry.trace.status")
                .and_then(|v| v.as_str()),
            Some("error"),
        );
    }

    #[test]
    fn test_normalize_trace_status_no_status() {
        let mut attributes = Annotated::empty();
        normalize_trace_status(&mut attributes, &Annotated::new(true), &Annotated::empty());
        assert!(
            attributes
                .value()
                .unwrap()
                .get_value("sentry.trace.status")
                .is_none(),
        );
    }

    #[test]
    fn test_normalize_received_none() {
        let mut attributes = Default::default();

        normalize_received(
            &mut attributes,
            DateTime::from_timestamp_nanos(1_234_201_337),
        );

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.observed_timestamp_nanos": {
            "type": "string",
            "value": "1234201337"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_received_existing() {
        let mut attributes = Annotated::from_json(
            r#"{
          "sentry.observed_timestamp_nanos": {
            "type": "string",
            "value": "111222333"
          }
        }"#,
        )
        .unwrap();

        normalize_received(
            &mut attributes,
            DateTime::from_timestamp_nanos(1_234_201_337),
        );

        assert_annotated_snapshot!(attributes, @r###"
        {
          "sentry.observed_timestamp_nanos": {
            "type": "string",
            "value": "111222333"
          }
        }
        "###);
    }

    #[test]
    fn test_process_attribute_types() {
        let json = r#"{
            "valid_bool": {
                "type": "boolean",
                "value": true
            },
            "valid_int_i64": {
                "type": "integer",
                "value": -42
            },
            "valid_int_u64": {
                "type": "integer",
                "value": 42
            },
            "valid_int_from_string": {
                "type": "integer",
                "value": "42"
            },
            "valid_double": {
                "type": "double",
                "value": 42.5
            },
            "double_with_i64": {
                "type": "double",
                "value": -42
            },
            "valid_double_with_u64": {
                "type": "double",
                "value": 42
            },
            "valid_string": {
                "type": "string",
                "value": "test"
            },
            "valid_string_with_other": {
                "type": "string",
                "value": "test",
                "some_other_field": "some_other_value"
            },
            "unknown_type": {
                "type": "custom",
                "value": "test"
            },
            "invalid_int_from_invalid_string": {
                "type": "integer",
                "value": "abc"
            },
            "invalid_int": {
                "type": "integer",
                "value": 9223372036854775808
            },
            "missing_type": {
                "value": "value with missing type"
            },
            "missing_value": {
                "type": "string"
            },
            "supported_array_string": {
                "type": "array",
                "value": ["foo", "bar"]
            },
            "supported_array_double": {
                "type": "array",
                "value": [3, 3.0, 3]
            },
            "supported_array_null": {
                "type": "array",
                "value": [null, null]
            },
            "unsupported_array_mixed": {
                "type": "array",
                "value": ["foo", 1.0]
            },
            "unsupported_array_object": {
                "type": "array",
                "value": [{}]
            },
            "unsupported_array_in_array": {
                "type": "array",
                "value": [[]]
            }
        }"#;

        let mut attributes = Annotated::<Attributes>::from_json(json).unwrap();
        normalize_attribute_types(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "double_with_i64": {
            "type": "double",
            "value": -42
          },
          "invalid_int": null,
          "invalid_int_from_invalid_string": null,
          "missing_type": null,
          "missing_value": null,
          "supported_array_double": {
            "type": "array",
            "value": [
              3,
              3.0,
              3
            ]
          },
          "supported_array_null": {
            "type": "array",
            "value": [
              null,
              null
            ]
          },
          "supported_array_string": {
            "type": "array",
            "value": [
              "foo",
              "bar"
            ]
          },
          "unknown_type": null,
          "unsupported_array_in_array": null,
          "unsupported_array_mixed": null,
          "unsupported_array_object": null,
          "valid_bool": {
            "type": "boolean",
            "value": true
          },
          "valid_double": {
            "type": "double",
            "value": 42.5
          },
          "valid_double_with_u64": {
            "type": "double",
            "value": 42
          },
          "valid_int_from_string": null,
          "valid_int_i64": {
            "type": "integer",
            "value": -42
          },
          "valid_int_u64": {
            "type": "integer",
            "value": 42
          },
          "valid_string": {
            "type": "string",
            "value": "test"
          },
          "valid_string_with_other": {
            "type": "string",
            "value": "test",
            "some_other_field": "some_other_value"
          },
          "_meta": {
            "invalid_int": {
              "": {
                "err": [
                  "invalid_data"
                ],
                "val": {
                  "type": "integer",
                  "value": 9223372036854775808
                }
              }
            },
            "invalid_int_from_invalid_string": {
              "": {
                "err": [
                  "invalid_data"
                ],
                "val": {
                  "type": "integer",
                  "value": "abc"
                }
              }
            },
            "missing_type": {
              "": {
                "err": [
                  "missing_attribute"
                ],
                "val": {
                  "type": null,
                  "value": "value with missing type"
                }
              }
            },
            "missing_value": {
              "": {
                "err": [
                  "missing_attribute"
                ],
                "val": {
                  "type": "string",
                  "value": null
                }
              }
            },
            "unknown_type": {
              "": {
                "err": [
                  "invalid_data"
                ],
                "val": {
                  "type": "custom",
                  "value": "test"
                }
              }
            },
            "unsupported_array_in_array": {
              "": {
                "err": [
                  "invalid_data"
                ]
              }
            },
            "unsupported_array_mixed": {
              "": {
                "err": [
                  "invalid_data"
                ]
              }
            },
            "unsupported_array_object": {
              "": {
                "err": [
                  "invalid_data"
                ]
              }
            },
            "valid_int_from_string": {
              "": {
                "err": [
                  "invalid_data"
                ],
                "val": {
                  "type": "integer",
                  "value": "42"
                }
              }
            }
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_user_agent_none() {
        let mut attributes = Default::default();
        normalize_user_agent(
            &mut attributes,
            Some(ClientUserAgentInfo {
                user_agent: Some(
                    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
                ),
                ..Default::default()
            }),
        );

        assert_annotated_snapshot!(attributes, @r###"
        {
          "browser.name": {
            "type": "string",
            "value": "Chrome"
          },
          "browser.version": {
            "type": "string",
            "value": "131.0.0"
          },
          "user_agent.original": {
            "type": "string",
            "value": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
          }
        }
        "###);
    }

    #[test]
    fn test_normalize_user_agent_existing() {
        let mut attributes = Annotated::from_json(
            r#"{
          "browser.name": {
            "type": "string",
            "value": "Very Special"
          },
          "browser.version": {
            "type": "string",
            "value": "13.3.7"
          }
        }"#,
        )
        .unwrap();

        normalize_user_agent(
            &mut attributes,
            Some(ClientUserAgentInfo {
                user_agent: Some(
                    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
                ),
                ..Default::default()
            }),
        );

        assert_annotated_snapshot!(attributes, @r#"
        {
          "browser.name": {
            "type": "string",
            "value": "Very Special"
          },
          "browser.version": {
            "type": "string",
            "value": "13.3.7"
          }
        }
        "#
        );
    }

    #[test]
    fn test_normalize_user_geo_none() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "192.168.2.1"
          }
        }"#,
        )
        .unwrap();

        normalize_user_geo(&mut attributes, |addr| {
            Some(Geo {
                country_code: "XY".to_owned().into(),
                city: addr.to_string().into(),
                subdivision: Annotated::empty(),
                region: "Illu".to_owned().into(),
                other: Default::default(),
            })
        });

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "192.168.2.1"
          },
          "user.geo.city": {
            "type": "string",
            "value": "192.168.2.1"
          },
          "user.geo.country_code": {
            "type": "string",
            "value": "XY"
          },
          "user.geo.region": {
            "type": "string",
            "value": "Illu"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_user_geo_existing() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "192.168.2.1"
          },
          "user.geo.city": {
            "type": "string",
            "value": "Foo Hausen"
          }
        }"#,
        )
        .unwrap();

        normalize_user_geo(&mut attributes, |_| unreachable!());

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "192.168.2.1"
          },
          "user.geo.city": {
            "type": "string",
            "value": "Foo Hausen"
          }
        }
        "#
        );
    }

    #[test]
    fn test_normalize_user_geo_subregion() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "192.168.2.1"
          }
        }"#,
        )
        .unwrap();

        normalize_user_geo(&mut attributes, |_| {
            Some(Geo {
                country_code: "AT".to_owned().into(),
                city: Annotated::empty(),
                subdivision: Annotated::empty(),
                region: Annotated::empty(),
                other: Default::default(),
            })
        });

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "192.168.2.1"
          },
          "user.geo.country_code": {
            "type": "string",
            "value": "AT"
          },
          "user.geo.subregion": {
            "type": "string",
            "value": "155"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_attributes() {
        fn replace_key(fragment: &str) -> String {
            format!("placeholder.replaced.{fragment}")
        }

        fn backfill_key(fragment: &str) -> String {
            format!("placeholder.backfilled.{fragment}")
        }

        fn mock_attribute_info(name: &str) -> Option<(&'static AttributeInfo, Option<&str>)> {
            use relay_conventions::ApplyScrubbing;

            match name {
                "replace.empty" => Some((
                    &AttributeInfo {
                        write_behavior: WriteBehavior::NewName(ReplacementName::Static("replaced")),
                        apply_scrubbing: ApplyScrubbing::Manual,
                        aliases: &["replaced"],
                    },
                    None,
                )),
                "replace.existing" => Some((
                    &AttributeInfo {
                        write_behavior: WriteBehavior::NewName(ReplacementName::Static(
                            "not.replaced",
                        )),
                        apply_scrubbing: ApplyScrubbing::Manual,
                        aliases: &["not.replaced"],
                    },
                    None,
                )),
                "backfill.empty" => Some((
                    &AttributeInfo {
                        write_behavior: WriteBehavior::BothNames(ReplacementName::Static(
                            "backfilled",
                        )),
                        apply_scrubbing: ApplyScrubbing::Manual,
                        aliases: &["backfilled"],
                    },
                    None,
                )),
                "backfill.existing" => Some((
                    &AttributeInfo {
                        write_behavior: WriteBehavior::BothNames(ReplacementName::Static(
                            "not.backfilled",
                        )),
                        apply_scrubbing: ApplyScrubbing::Manual,
                        aliases: &["not.backfilled"],
                    },
                    None,
                )),
                _ if let Some(fragment) = name.strip_prefix("placeholder.replace.") => Some((
                    &AttributeInfo {
                        write_behavior: WriteBehavior::NewName(ReplacementName::Dynamic(
                            replace_key,
                        )),
                        apply_scrubbing: ApplyScrubbing::Manual,
                        aliases: &["placeholder.replaced.<key>"],
                    },
                    Some(fragment),
                )),
                _ if let Some(fragment) = name.strip_prefix("placeholder.backfill.") => Some((
                    &AttributeInfo {
                        write_behavior: WriteBehavior::BothNames(ReplacementName::Dynamic(
                            backfill_key,
                        )),
                        apply_scrubbing: ApplyScrubbing::Manual,
                        aliases: &["placeholder.backfilled.<key>"],
                    },
                    Some(fragment),
                )),

                _ => None,
            }
        }

        let mut attributes = Attributes::from([
            (
                "replace.empty".to_owned(),
                Annotated::new("Should be moved".to_owned().into()),
            ),
            (
                "replace.existing".to_owned(),
                Annotated::new("Should be removed".to_owned().into()),
            ),
            (
                "placeholder.replace.foo".to_owned(),
                Annotated::new("Should be moved".to_owned().into()),
            ),
            (
                "not.replaced".to_owned(),
                Annotated::new("Should be left alone".to_owned().into()),
            ),
            (
                "backfill.empty".to_owned(),
                Annotated::new("Should be copied".to_owned().into()),
            ),
            (
                "backfill.existing".to_owned(),
                Annotated::new("Should be left alone".to_owned().into()),
            ),
            (
                "placeholder.backfill.bar".to_owned(),
                Annotated::new("Should be copied".to_owned().into()),
            ),
            (
                "not.backfilled".to_owned(),
                Annotated::new("Should be left alone".to_owned().into()),
            ),
        ]);

        normalize_attribute_names_inner(&mut attributes.0, mock_attribute_info);

        assert_annotated_snapshot!(Annotated::new(attributes), @r###"
        {
          "backfill.empty": {
            "type": "string",
            "value": "Should be copied"
          },
          "backfill.existing": {
            "type": "string",
            "value": "Should be left alone"
          },
          "backfilled": {
            "type": "string",
            "value": "Should be copied"
          },
          "not.backfilled": {
            "type": "string",
            "value": "Should be left alone"
          },
          "not.replaced": {
            "type": "string",
            "value": "Should be left alone"
          },
          "placeholder.backfill.bar": {
            "type": "string",
            "value": "Should be copied"
          },
          "placeholder.backfilled.bar": {
            "type": "string",
            "value": "Should be copied"
          },
          "placeholder.replace.foo": null,
          "placeholder.replaced.foo": {
            "type": "string",
            "value": "Should be moved"
          },
          "replace.empty": null,
          "replace.existing": null,
          "replaced": {
            "type": "string",
            "value": "Should be moved"
          },
          "_meta": {
            "placeholder.replace.foo": {
              "": {
                "rem": [
                  [
                    "attribute.deprecated",
                    "x"
                  ]
                ]
              }
            },
            "replace.empty": {
              "": {
                "rem": [
                  [
                    "attribute.deprecated",
                    "x"
                  ]
                ]
              }
            },
            "replace.existing": {
              "": {
                "rem": [
                  [
                    "attribute.deprecated",
                    "x"
                  ]
                ]
              }
            }
          }
        }
        "###);
    }

    #[test]
    fn test_normalize_span_infers_op() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "db.system.name": {
                "type": "string",
                "value": "mysql"
            },
            "db.operation.name": {
                "type": "string",
                "value": "query"
            }
        }
        "#,
        )
        .unwrap();

        normalize_sentry_op(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "db.operation.name": {
            "type": "string",
            "value": "query"
          },
          "db.system.name": {
            "type": "string",
            "value": "mysql"
          },
          "sentry.op": {
            "type": "string",
            "value": "db"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_attribute_values_mysql_db_query_attributes() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.op": {
            "type": "string",
            "value": "db.query"
          },
          "sentry.origin": {
            "type": "string",
            "value": "auto.otlp.spans"
          },
          "db.system.name": {
            "type": "string",
            "value": "mysql"
          },
          "db.query.text": {
            "type": "string",
            "value": "SELECT \"not an identifier\""
          }
        }
        "#,
        )
        .unwrap();

        normalize_db_attributes(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "db.operation.name": {
            "type": "string",
            "value": "SELECT"
          },
          "db.query.text": {
            "type": "string",
            "value": "SELECT \"not an identifier\""
          },
          "db.system.name": {
            "type": "string",
            "value": "mysql"
          },
          "sentry.normalized_db_query": {
            "type": "string",
            "value": "SELECT %s"
          },
          "sentry.normalized_db_query.hash": {
            "type": "string",
            "value": "3a377dcc490b1690"
          },
          "sentry.op": {
            "type": "string",
            "value": "db.query"
          },
          "sentry.origin": {
            "type": "string",
            "value": "auto.otlp.spans"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_mongodb_db_query_attributes() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.op": {
            "type": "string",
            "value": "db"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "db.query.text": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "db.operation.name": {
            "type": "string",
            "value": "find"
          },
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          }
        }
        "#,
        )
        .unwrap();

        normalize_db_attributes(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          },
          "db.operation.name": {
            "type": "string",
            "value": "FIND"
          },
          "db.query.text": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.normalized_db_query": {
            "type": "string",
            "value": "{\"find\":\"documents\",\"foo\":\"?\"}"
          },
          "sentry.normalized_db_query.hash": {
            "type": "string",
            "value": "aedc5c7e8cec726b"
          },
          "sentry.op": {
            "type": "string",
            "value": "db"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_db_attributes_does_not_update_attributes_if_already_normalized() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          },
          "db.operation.name": {
            "type": "string",
            "value": "FIND"
          },
          "db.query.text": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.normalized_db_query": {
            "type": "string",
            "value": "{\"find\":\"documents\",\"foo\":\"?\"}"
          },
          "sentry.op": {
            "type": "string",
            "value": "db"
          }
        }
        "#,
        )
        .unwrap();

        normalize_db_attributes(&mut attributes);

        insta::assert_json_snapshot!(
            SerializableAnnotated(&attributes), @r#"
        {
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          },
          "db.operation.name": {
            "type": "string",
            "value": "FIND"
          },
          "db.query.text": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.normalized_db_query": {
            "type": "string",
            "value": "{\"find\":\"documents\",\"foo\":\"?\"}"
          },
          "sentry.op": {
            "type": "string",
            "value": "db"
          }
        }
        "#
        );
    }

    #[test]
    fn test_normalize_db_attributes_does_not_change_non_db_spans() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "sentry.origin": {
            "type": "string",
            "value": "auto.otlp.spans"
          },
          "http.request.method": {
            "type": "string",
            "value": "GET"
          }
        }
      "#,
        )
        .unwrap();

        normalize_db_attributes(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "sentry.origin": {
            "type": "string",
            "value": "auto.otlp.spans"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_http_attributes() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "url.full": {
            "type": "string",
            "value": "https://application.www.xn--85x722f.xn--55qx5d.cn"
          }
        }
      "#,
        )
        .unwrap();

        normalize_http_attributes(&mut attributes, &[]);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "server.address": {
            "type": "string",
            "value": "*.xn--85x722f.xn--55qx5d.cn"
          },
          "url.full": {
            "type": "string",
            "value": "https://application.www.xn--85x722f.xn--55qx5d.cn"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_http_attributes_server_address() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "url.scheme": {
            "type": "string",
            "value": "https"
          },
          "server.address": {
            "type": "string",
            "value": "subdomain.example.com:5688"
          },
          "http.request.method": {
            "type": "string",
            "value": "GET"
          }
        }
      "#,
        )
        .unwrap();

        normalize_http_attributes(&mut attributes, &[]);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "server.address": {
            "type": "string",
            "value": "*.example.com:5688"
          },
          "url.full": {
            "type": "string",
            "value": "https://subdomain.example.com:5688"
          },
          "url.scheme": {
            "type": "string",
            "value": "https"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_http_attributes_allowed_hosts() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "url.full": {
            "type": "string",
            "value": "https://application.www.xn--85x722f.xn--55qx5d.cn"
          }
        }
      "#,
        )
        .unwrap();

        normalize_http_attributes(
            &mut attributes,
            &["application.www.xn--85x722f.xn--55qx5d.cn".to_owned()],
        );

        assert_annotated_snapshot!(attributes, @r#"
        {
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "server.address": {
            "type": "string",
            "value": "application.www.xn--85x722f.xn--55qx5d.cn"
          },
          "url.full": {
            "type": "string",
            "value": "https://application.www.xn--85x722f.xn--55qx5d.cn"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_db_attributes_from_legacy_attributes() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.op": {
            "type": "string",
            "value": "db"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.description": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "db.operation.name": {
            "type": "string",
            "value": "find"
          },
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          }
        }
        "#,
        )
        .unwrap();

        normalize_db_attributes(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          },
          "db.operation.name": {
            "type": "string",
            "value": "FIND"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.description": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "sentry.normalized_db_query": {
            "type": "string",
            "value": "{\"find\":\"documents\",\"foo\":\"?\"}"
          },
          "sentry.normalized_db_query.hash": {
            "type": "string",
            "value": "aedc5c7e8cec726b"
          },
          "sentry.op": {
            "type": "string",
            "value": "db"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_http_attributes_from_legacy_attributes() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "http.request_method": {
            "type": "string",
            "value": "GET"
          }
        }
        "#,
        )
        .unwrap();

        normalize_attribute_names(&mut attributes);
        normalize_http_attributes(&mut attributes, &[]);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "http.request_method": {
            "type": "string",
            "value": "GET"
          },
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_http_attributes_from_description() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "sentry.description": {
            "type": "string",
            "value": "GET https://application.www.xn--85x722f.xn--55qx5d.cn"
          }
        }
        "#,
        )
        .unwrap();

        normalize_http_attributes(&mut attributes, &[]);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.description": {
            "type": "string",
            "value": "GET https://application.www.xn--85x722f.xn--55qx5d.cn"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          },
          "server.address": {
            "type": "string",
            "value": "*.xn--85x722f.xn--55qx5d.cn"
          },
          "url.full": {
            "type": "string",
            "value": "https://application.www.xn--85x722f.xn--55qx5d.cn"
          }
        }
        "#);
    }

    #[test]
    fn test_write_legacy_attributes() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"
        {
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          },
          "db.operation.name": {
            "type": "string",
            "value": "FIND"
          },
          "db.query.text": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.normalized_db_query": {
            "type": "string",
            "value": "{\"find\":\"documents\",\"foo\":\"?\"}"
          },
          "sentry.normalized_db_query.hash": {
            "type": "string",
            "value": "aedc5c7e8cec726b"
          },
          "sentry.op": {
            "type": "string",
            "value": "db"
          }
        }
        "#,
        )
        .unwrap();

        write_legacy_attributes(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "db.collection.name": {
            "type": "string",
            "value": "documents"
          },
          "db.operation.name": {
            "type": "string",
            "value": "FIND"
          },
          "db.query.text": {
            "type": "string",
            "value": "{\"find\": \"documents\", \"foo\": \"bar\"}"
          },
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.action": {
            "type": "string",
            "value": "FIND"
          },
          "sentry.domain": {
            "type": "string",
            "value": ",documents,"
          },
          "sentry.group": {
            "type": "string",
            "value": "aedc5c7e8cec726b"
          },
          "sentry.normalized_db_query": {
            "type": "string",
            "value": "{\"find\":\"documents\",\"foo\":\"?\"}"
          },
          "sentry.normalized_db_query.hash": {
            "type": "string",
            "value": "aedc5c7e8cec726b"
          },
          "sentry.normalized_description": {
            "type": "string",
            "value": "{\"find\":\"documents\",\"foo\":\"?\"}"
          },
          "sentry.op": {
            "type": "string",
            "value": "db"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_explicit() {
        // Category is already explicitly set, should not be overwritten
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "sentry.category": {
            "type": "string",
            "value": "custom"
          },
          "sentry.op": {
            "type": "string",
            "value": "db.query"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "custom"
          },
          "sentry.op": {
            "type": "string",
            "value": "db.query"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_op_db() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "sentry.op": {
            "type": "string",
            "value": "db.query"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "db"
          },
          "sentry.op": {
            "type": "string",
            "value": "db.query"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_op_http() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "http"
          },
          "sentry.op": {
            "type": "string",
            "value": "http.client"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_op_ui_framework() {
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "sentry.op": {
            "type": "string",
            "value": "ui.react.render"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "ui.react"
          },
          "sentry.op": {
            "type": "string",
            "value": "ui.react.render"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_db_system() {
        // Category derived from db.system.name when no op
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "db.system.name": {
            "type": "string",
            "value": "mongodb"
          },
          "sentry.category": {
            "type": "string",
            "value": "db"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_http_method() {
        // Category derived from http.request.method when no op or db
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "http.request.method": {
            "type": "string",
            "value": "GET"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "http.request.method": {
            "type": "string",
            "value": "GET"
          },
          "sentry.category": {
            "type": "string",
            "value": "http"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_ui_component() {
        // Category derived from ui.component_name
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "ui.component_name": {
            "type": "string",
            "value": "MyComponent"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "ui"
          },
          "ui.component_name": {
            "type": "string",
            "value": "MyComponent"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_resource() {
        // Category derived from resource.render_blocking_status
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "resource.render_blocking_status": {
            "type": "string",
            "value": "blocking"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "resource.render_blocking_status": {
            "type": "string",
            "value": "blocking"
          },
          "sentry.category": {
            "type": "string",
            "value": "resource"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_from_browser_origin() {
        // Category derived from sentry.origin with browser metrics value
        let mut attributes = Annotated::from_json(
            r#"{
          "sentry.origin": {
            "type": "string",
            "value": "auto.ui.browser.metrics"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.category": {
            "type": "string",
            "value": "browser"
          },
          "sentry.origin": {
            "type": "string",
            "value": "auto.ui.browser.metrics"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_address_auto_with_ip() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "{{auto}}"
          }
        }"#,
        )
        .unwrap();

        normalize_client_address(&mut attributes, Some("192.168.1.1".parse().unwrap()));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "192.168.1.1"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_address_auto_without_ip() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "{{auto}}"
          }
        }"#,
        )
        .unwrap();

        normalize_client_address(&mut attributes, None);

        assert_annotated_snapshot!(attributes, @r#"
        {}
        "#);
    }

    #[test]
    fn test_normalize_client_address_explicit_not_replaced() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "10.0.0.1"
          }
        }"#,
        )
        .unwrap();

        normalize_client_address(&mut attributes, Some("192.168.1.1".parse().unwrap()));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "10.0.0.1"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_address_missing_attribute() {
        let mut attributes = Annotated::empty();

        normalize_client_address(&mut attributes, Some("192.168.1.1".parse().unwrap()));

        assert!(attributes.is_empty());
    }

    #[test]
    fn test_normalize_client_address_auto_with_ipv6() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "{{auto}}"
          }
        }"#,
        )
        .unwrap();

        normalize_client_address(&mut attributes, Some("2001:db8::1".parse().unwrap()));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "2001:db8::1"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_inject_client_address_inserts_when_missing() {
        let mut attributes = Annotated::empty();

        normalize_inject_client_address(&mut attributes, Some("192.168.1.1".parse().unwrap()));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "192.168.1.1"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_inject_client_address_does_not_overwrite() {
        let mut attributes = Annotated::from_json(
            r#"{
          "client.address": {
            "type": "string",
            "value": "10.0.0.1"
          }
        }"#,
        )
        .unwrap();

        normalize_inject_client_address(&mut attributes, Some("192.168.1.1".parse().unwrap()));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "10.0.0.1"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_inject_client_address_none_ip() {
        let mut attributes = Annotated::from_json(r#"{}"#).unwrap();

        normalize_inject_client_address(&mut attributes, None);

        assert_annotated_snapshot!(attributes, @r#"
        {}
        "#);
    }

    #[test]
    fn test_normalize_inject_client_address_ipv6() {
        let mut attributes = Annotated::empty();

        normalize_inject_client_address(&mut attributes, Some("2001:db8::1".parse().unwrap()));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "client.address": {
            "type": "string",
            "value": "2001:db8::1"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_span_category_no_match() {
        // No category derived when no relevant attributes are present
        let mut attributes = Annotated::<Attributes>::from_json(
            r#"{
          "some.other.attribute": {
            "type": "string",
            "value": "value"
          }
        }"#,
        )
        .unwrap();

        normalize_span_category(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "some.other.attribute": {
            "type": "string",
            "value": "value"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_release_valid() {
        let mut attributes = Annotated::from_json(
            r#"{
          "sentry.release": {
            "type": "string",
            "value": "my-app@1.0.0"
          }
        }"#,
        )
        .unwrap();

        normalize_release(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.release": {
            "type": "string",
            "value": "my-app@1.0.0"
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_release_invalid() {
        let mut attributes = Annotated::from_json(
            r#"{
          "sentry.release": {
            "type": "string",
            "value": "latest"
          }
        }"#,
        )
        .unwrap();

        normalize_release(&mut attributes);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.release": null,
          "_meta": {
            "sentry.release": {
              "": {
                "err": [
                  "invalid_data"
                ],
                "val": {
                  "type": "string",
                  "value": "latest"
                }
              }
            }
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_release_too_long() {
        let mut attributes = Annotated::new(Attributes::new());
        attributes
            .get_or_insert_with(Default::default)
            .insert(SENTRY__RELEASE, "a".repeat(251));

        normalize_release(&mut attributes);

        let release = attributes.value().unwrap().0.get(SENTRY__RELEASE).unwrap();
        assert!(release.value().is_none());
        assert!(release.meta().has_errors());
    }

    #[test]
    fn test_normalize_client_sample_rate_valid() {
        let mut attributes = Annotated::from_json(
            r#"{
          "sentry.client_sample_rate": {
            "type": "double",
            "value": 1.0
          }
        }"#,
        )
        .unwrap();

        normalize_client_sample_rate(&mut attributes, None);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.client_sample_rate": {
            "type": "double",
            "value": 1.0
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_sample_rate_missing_uses_dsc() {
        let mut attributes = Annotated::new(Attributes::new());

        normalize_client_sample_rate(&mut attributes, Some(0.25));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.client_sample_rate": {
            "type": "double",
            "value": 0.25
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_sample_rate_missing_defaults_to_one() {
        let mut attributes = Annotated::new(Attributes::new());

        normalize_client_sample_rate(&mut attributes, None);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.client_sample_rate": {
            "type": "double",
            "value": 1.0
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_sample_rate_invalid_dsc_marked_as_error() {
        let mut attributes = Annotated::new(Attributes::new());

        normalize_client_sample_rate(&mut attributes, Some(0.0));

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.client_sample_rate": null,
          "_meta": {
            "sentry.client_sample_rate": {
              "": {
                "err": [
                  [
                    "invalid_data",
                    {
                      "reason": "expected sample rate > 0.0, <= 1.0"
                    }
                  ]
                ]
              }
            }
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_sample_rate_invalid_too_small() {
        let mut attributes = {
            let mut attrs = Attributes::new();
            attrs.insert(SENTRY__CLIENT_SAMPLE_RATE, 0.0);
            Annotated::new(attrs)
        };

        normalize_client_sample_rate(&mut attributes, None);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.client_sample_rate": null,
          "_meta": {
            "sentry.client_sample_rate": {
              "": {
                "err": [
                  [
                    "invalid_data",
                    {
                      "reason": "expected sample rate > 0.0, <= 1.0"
                    }
                  ]
                ]
              }
            }
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_sample_rate_invalid_too_large() {
        let mut attributes = {
            let mut attrs = Attributes::new();
            attrs.insert(SENTRY__CLIENT_SAMPLE_RATE, 1.1);
            Annotated::new(attrs)
        };

        normalize_client_sample_rate(&mut attributes, None);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.client_sample_rate": null,
          "_meta": {
            "sentry.client_sample_rate": {
              "": {
                "err": [
                  [
                    "invalid_data",
                    {
                      "reason": "expected sample rate > 0.0, <= 1.0"
                    }
                  ]
                ]
              }
            }
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_client_sample_rate_invalid_type() {
        let mut attributes = {
            let mut attrs = Attributes::new();
            attrs.insert(SENTRY__CLIENT_SAMPLE_RATE, "foobar");
            Annotated::new(attrs)
        };

        normalize_client_sample_rate(&mut attributes, None);

        assert_annotated_snapshot!(attributes, @r#"
        {
          "sentry.client_sample_rate": null,
          "_meta": {
            "sentry.client_sample_rate": {
              "": {
                "err": [
                  [
                    "invalid_data",
                    {
                      "reason": "expected sample rate > 0.0, <= 1.0"
                    }
                  ]
                ]
              }
            }
          }
        }
        "#);
    }

    #[test]
    fn test_normalize_mobile_measurements() {
        let json = r#"
        {
            "frames.slow": {"value": 1, "type": "integer"},
            "app.vitals.frames.frozen.count": {"value": 2, "type": "integer"},
            "frames.total": {"value": 4, "type": "integer"},
            "stall_total_time": {"value": 4000, "type": "integer"}
        }
        "#;

        let mut attributes = Annotated::<Attributes>::from_json(json).unwrap();

        normalize_attribute_names(&mut attributes);
        normalize_mobile_measurements(&mut attributes, Some(Duration::from_secs(5)));

        insta::assert_json_snapshot!(SerializableAnnotated(&attributes),  @r#"
        {
          "app.vitals.frames.frozen.count": {
            "type": "integer",
            "value": 2
          },
          "app.vitals.frames.frozen.rate": {
            "type": "double",
            "value": 0.5
          },
          "app.vitals.frames.slow.count": {
            "type": "integer",
            "value": 1
          },
          "app.vitals.frames.slow.rate": {
            "type": "double",
            "value": 0.25
          },
          "app.vitals.frames.total.count": {
            "type": "integer",
            "value": 4
          },
          "app.vitals.stall.duration": {
            "type": "integer",
            "value": 4000
          },
          "app.vitals.stall.percentage": {
            "type": "double",
            "value": 0.8
          },
          "frames.slow": {
            "type": "integer",
            "value": 1
          },
          "frames.total": {
            "type": "integer",
            "value": 4
          },
          "stall_total_time": {
            "type": "integer",
            "value": 4000
          }
        }
        "#);
    }
}