otelite-core 0.1.36

Core telemetry domain types for the Otelite OpenTelemetry receiver
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

//! Helpers for formatting telemetry attribute values.

use serde_json::Value;

/// If the string is valid JSON, return it pretty-printed. Otherwise return as-is.
#[must_use]
pub fn format_attribute_value(value: &str) -> String {
    if let Ok(parsed) = serde_json::from_str::<Value>(value) {
        serde_json::to_string_pretty(&parsed).unwrap_or_else(|_| value.to_string())
    } else {
        value.to_string()
    }
}

/// Return a truncated preview of a JSON value (first N chars + "...")
#[must_use]
pub fn format_attribute_preview(value: &str, max_chars: usize) -> String {
    if let Ok(parsed) = serde_json::from_str::<Value>(value) {
        match parsed {
            Value::Object(map) => format!("{{object, {} keys}}", map.len()),
            Value::Array(items) => format!("[array, {} items]", items.len()),
            _ => truncate_with_ellipsis(value, max_chars),
        }
    } else {
        truncate_with_ellipsis(value, max_chars)
    }
}

fn truncate_with_ellipsis(value: &str, max_chars: usize) -> String {
    let char_count = value.chars().count();

    if char_count <= max_chars {
        return value.to_string();
    }

    if max_chars <= 3 {
        return ".".repeat(max_chars);
    }

    let truncated: String = value.chars().take(max_chars - 3).collect();
    format!("{truncated}...")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_format_json_object() {
        let input = r#"{"key":"value","nested":{"a":1}}"#;
        let output = format_attribute_value(input);
        assert!(output.contains('\n'));
    }

    #[test]
    fn test_format_plain_string() {
        assert_eq!(format_attribute_value("hello"), "hello");
    }

    #[test]
    fn test_format_json_array() {
        let input = r#"[1,2,3]"#;
        let output = format_attribute_value(input);
        assert!(output.contains('\n'));
    }

    #[test]
    fn test_format_attribute_preview_for_object() {
        let input = r#"{"key":"value","nested":{"a":1}}"#;
        assert_eq!(format_attribute_preview(input, 10), "{object, 2 keys}");
    }

    #[test]
    fn test_format_attribute_preview_for_array() {
        let input = r#"[1,2,3]"#;
        assert_eq!(format_attribute_preview(input, 10), "[array, 3 items]");
    }

    #[test]
    fn test_format_attribute_preview_for_plain_string() {
        assert_eq!(format_attribute_preview("hello world", 8), "hello...");
    }
}