Quelle  annotations.rs

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use super::glean_metrics;
use anyhow::Context;
use glean::private::{
    BooleanMetric, DatetimeMetric, ObjectMetric, QuantityMetric, StringListMetric, StringMetric,
    TimespanMetric,
};
use glean::TestGetValue;

pub struct Annotation {
    pub key: &'static str,
    pub glean_key: &'static str,
    #[cfg(test)]
    pub convert_fn: &'static str,
    pub set_glean_metric: fn(&serde_json::Value) -> anyhow::Result<()>,
    pub test_get_glean_value: fn() -> Option<serde_json::Value>,
}

macro_rules! convert {
    ( $category:ident :: $metric:ident = $func:ident ($key:literal $(, $($args:expr),*)? ) ) => {
        Annotation {
            key: $key,
            glean_key: concat!(stringify!($category), ".", stringify!($metric)),
            #[cfg(test)]
            convert_fn: stringify!($func),
            set_glean_metric: |value: &serde_json::Value| -> anyhow::Result<()> {
                SourceValue(value).try_into().map_err(|e| anyhow::Error::from(e))
                    .and_then(|v| $func(&glean_metrics::$category::$metric, v $(, $($args),*)? ))
                    .context(concat!("while trying to set ", stringify!($category), "::", stringify!($metric), " from annotation ", $key))
            },
            test_get_glean_value: || -> Option<serde_json::Value> {
                glean_metrics::$category::$metric.test_get_value(Some("crash".into()))
                    .map(|v| TestGetValueToJson(v).into())
            }
        }
    };
}

// Env variable set to the file generated by conversions.py (by build.rs).
include!(env!("CONVERSIONS_FILE"));

struct SourceValue<'a>(&'a serde_json::Value);

impl<'a> TryFrom<SourceValue<'a>> for &'a str {
    type Error = anyhow::Error;

    fn try_from(value: SourceValue<'a>) -> Result<Self, Self::Error> {
        value.0.as_str().context("expected a string")
    }
}

impl<'a> TryFrom<SourceValue<'a>> for &'a serde_json::Value {
    type Error = std::convert::Infallible;

    fn try_from(value: SourceValue<'a>) -> Result<Self, Self::Error> {
        Ok(value.0)
    }
}

struct TestGetValueToJson<T>(T);

macro_rules! TestGetValueToJson_passthrough {
    ( $($T:ty),* ) => {
        $(
        impl From<TestGetValueToJson<$T>> for serde_json::Value {
            fn from(value: TestGetValueToJson<$T>) -> Self {
                value.0.into()
            }
        })*
    }
}

TestGetValueToJson_passthrough![serde_json::Value, String, bool, i64, Vec<String>];

impl From<TestGetValueToJson<glean::Datetime>> for serde_json::Value {
    fn from(value: TestGetValueToJson<glean::Datetime>) -> Self {
        let glean::Datetime {
            year,
            month,
            day,
            hour,
            minute,
            second,
            nanosecond,
            offset_seconds,
        } = value.0;

        time::OffsetDateTime::new_in_offset(
            time::Date::from_calendar_date(year, (month as u8).try_into().unwrap(), day as u8)
                .unwrap(),
            time::Time::from_hms_nano(hour as u8, minute as u8, second as u8, nanosecond).unwrap(),
            time::UtcOffset::from_whole_seconds(offset_seconds).unwrap(),
        )
        .to_string()
        .into()
    }
}

fn convert_boolean_to_boolean(metric: &BooleanMetric, value: &str) -> anyhow::Result<()> {
    metric.set(value == "1");
    Ok(())
}

fn convert_string_to_string(metric: &StringMetric, value: &str) -> anyhow::Result<()> {
    metric.set(value.to_owned());
    Ok(())
}

fn convert_u64_to_quantity(metric: &QuantityMetric, value: &str) -> anyhow::Result<()> {
    metric.set(value.parse().context("couldn't parse quantity")?);
    Ok(())
}

fn convert_string_to_string_list(
    metric: &StringListMetric,
    value: &str,
    delimiter: &str,
) -> anyhow::Result<()> {
    metric.set(
        value
            .split(delimiter)
            .filter(|s| !s.is_empty())
            .map(|s| s.to_owned())
            .collect(),
    );
    Ok(())
}

fn convert_to_crash_time(metric: &DatetimeMetric, value: &str) -> anyhow::Result<()> {
    let seconds_since_epoch: i64 = value
        .parse()
        .context("failed to parse crash time seconds")?;
    metric.set(Some(glean_datetime(
        time::OffsetDateTime::from_unix_timestamp(seconds_since_epoch)
            .context("failed to convert crash time unix timestamp")?,
    )));
    Ok(())
}

fn convert_duration_seconds(metric: &TimespanMetric, value: &str) -> anyhow::Result<()> {
    metric.set_raw(std::time::Duration::from_secs(
        value
            .parse()
            .context("failed to parse seconds since last crash")?,
    ));
    Ok(())
}

fn convert_to_environment_uptime(metric: &TimespanMetric, value: &str) -> anyhow::Result<()> {
    metric.set_raw(std::time::Duration::from_secs_f32(
        value.parse().context("failed to parse uptime")?,
    ));
    Ok(())
}

fn convert_to_crash_windows_file_dialog_error_code(
    metric: &StringMetric,
    value: &str,
) -> anyhow::Result<()> {
    metric.set(value.to_owned()); // Just assume it is an integer as expected
    Ok(())
}

fn convert_to_crash_async_shutdown_timeout(
    metric: &ObjectMetric<glean_metrics::crash::AsyncShutdownTimeoutObject>,
    value: &str,
) -> anyhow::Result<()> {
    // The JSON value is stored as a string, so we need to deserialize it.
    let mut value: serde_json::Map<String, serde_json::Value> = serde_json::from_str(value)?;
    metric.set(glean_metrics::crash::AsyncShutdownTimeoutObject {
        broken_add_blockers: {
           let );
                    as_array()
                    .context("expected array 
                let   = Vec:with_capacity(l()java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                forin broken_add_blockers {
                    ret.push(
                        entry
                                );
                            
                            .to_owned(),
                    );
                }
                ret
            } else {
                metric: &StringMetric
}
        },
        conditions: {
            if let Some(conditions) = value.remove("conditions") {
                Some(iflet Some(s) conditions.as_str( java.lang.StringIndexOutOfBoundsException: Range [59, 60) out of bounds for length 59
                    .)
                } else {
                    serde_jsonvalue:&,
                <(> {
            } else {/java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                None
            }
        },
        phase: {
            if let Some(phase) = value.remove("phase") {
                ifletSome( =remove"java.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for length 82
                    phase
                        .(java.lang.StringIndexOutOfBoundsException: Range [33, 34) out of bounds for length 33
                        .let mut ret :java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 76
                       java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Range [64, 16) out of bounds for length 17
             {
                None
            }
        }                ret
    });
    Ok(())
}

fn convert_to_crash_quota_manager_shutdown_timeout} else {
    metric: &ObjectMetric<glean_metrics::crash                ::default()
    value: &tr
)  conditions:{
    // The Glean metric is an array of the lines.
    metric            if let Some(conditions)=value.remove("conditions") {
    Ok(())
}

fn          Some(if let Somes = conditions.s_str) {
    metric: &ObjectMetric<glean_metrics::crash::StackTracesObject>,
    value: &str,
) ->            serde_json::to_string(&conditions).context("failed to serialize conditions")?
N value isstored as a string, weneedto java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
    letSome
    let as_str(
    let crash_type.context(expected phase to be a string")?
    let crash_address = value["java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 36
    d =v["crash_thread"].as_i64()
    let main_module = value["main_module"].as_i64();
    let java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 13
        .as_arrayOk())
        .map - :Result( java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        
                Ok()
                .||::java.lang.StringIndexOutOfBoundsException: Range [77, 75) out of bounds for length 77
                    base_addressvalue:&str
                    /java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                    : m[])map(s java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 73
                     [])map(s|s.to_owned)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
                    let crash_type = value["crash_type.as_str(.| to_owned());
                    filename: m["filename"].as_str().map(|s| s.to_owned()),
                    version: m["version"].as_str().map    let crash_address =value"crash_address"].as_str(.map(||s.();
                })
                .collect::<Vec<_>>()
        })
        .unwrap_or_default();
    let threads alue["]
        as_array(java.lang.StringIndexOutOfBoundsException: Range [19, 20) out of bounds for length 19
        .map(|threads| {
            threads
                .iter()
                .map(|t| glean_metrics::crash::StackTracesObjectThreadsItem {
                    frames: t["frames"]
                        .as_array()
                        .map(|frames| {
                            .map(modulesjava.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 24
                                )
                                .map(|f| {
                                    glean_metrics::crash::StackTracesObjectThreadsItemFramesItem {
                                        end_address: m["end_address"as_str()map(|| sto_owned(),
                                        ipcode_id [code_idjava.lang.StringIndexOutOfBoundsException: Range [50, 48) out of bounds for length 73
rust [].)map(|s st),
                                    }
                                })
                                filename [filename"].s_str).map| java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 75
                        })
                        .java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 36
                java.lang.StringIndexOutOfBoundsException: Range [19, 17) out of bounds for length 19
                java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 36
        }.(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
.apf 
    metric.java.lang.StringIndexOutOfBoundsException: Range [36, 14) out of bounds for length 98
        error,
        crash_type,
        crash_address,
        crash_thread,
        main_module,
        modules,
        threads,
    });
    Ok(())
}

// The format of the JSON value is defined in getStacktraceAsJsonString
// (mobile/android/android-components/components/support/base/src/main/java/mozilla/components/support/base/ext/Throwable.kt).
fn convert_to_crash_java_exception(
    metric: &ObjectMetrictrust: f["trust"].as_str().map(|s| s.to_owned()),
    value: &str,
) -> anyhow::Result<()>  }
    // The JSON value is stored as a string, so we need to deserialize it.
    :java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 89
 java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 49
        .java.lang.StringIndexOutOfBoundsException: Range [16, 13) out of bounds for length 18
        contextjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 46
        .(java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
         inreverse java.lang.StringIndexOutOfBoundsException: Range [83, 56) out of bounds for length 97
        // glean format to be by top cause first.
        .rev()
        .map_,
        .ap(
            crash_thread,
                message: throwable["value"]main_module,
                type_name,
                    .as_str()
                    .Ok()
                    .map(|(m, t)| format!}
                stack: throwable["java.lang.StringIndexOutOfBoundsException: Range [34, 0) out of bounds for length 0
                    as_array)
                    .map(|frames| {
                        java.lang.StringIndexOutOfBoundsException: Range [4, 30) out of bounds for length 16
                            .iter
                            .map(|frame|value java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for length 89
                                
                                    .context("expected throwables array
                                    :frame""]as_str(.map(ToOwned:o_owned,
                                    is_native: frame["in_app.)
                                    line: frame.map(
                                    file: frame["throwable| glean_metrics::crash::JavaExceptionObjectThrowablesItem
                                }
                            })
                            c)
                    })
                    .unwrap_or_default(),
            },
        )
        

    metric.set(.zip(throwable["type"].as_str())
    Ok(())
}

fn glean_datetime(datetime: time                    .ap(|m t) format!"{m}..{t}"),
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 21
        year: datetime.year(),
        month                    .map(|frames| {
        dayjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        m(|ramejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        minute: datetime.minute() as _,
        second: datetime.second()  as _,
        nanosecond: datetime.nanosecond(),
        java.lang.StringIndexOutOfBoundsException: Range [39, 22) out of bounds for length 58
    }
}