Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

6.5 KB
Raw Blame
use std::io::Write;

use posthog_symbol_data::{
    read_symbol_data, read_symbol_data_with_byte_count_limited,
    symbol_data_known_decompressed_size, write_symbol_data, write_symbol_data_uncompressed,
    AppleDsym, ElfDebugInfo, HermesMap, ProguardMapping, SourceAndMap, SymbolDataError,
};

const MAGIC_LEN: usize = b"posthog_error_tracking".len();
const VERSION_OFFSET: usize = MAGIC_LEN;
const COMPRESSION_OFFSET: usize = MAGIC_LEN + 4 + 4; // after MAGIC + VERSION + TYPE

#[test]
fn test_source_and_map_reading() {
    // This file is v1 format - validates backward compatibility
    let input = include_bytes!("static/sourcemap_with_nulls.jsdata");
    read_symbol_data::<SourceAndMap>(input).unwrap();
}

#[test]
fn test_v2_compressed_header() {
    let input = SourceAndMap {
        minified_source: "minified_source".to_string(),
        sourcemap: "sourcemap".to_string(),
    };

    let bytes = write_symbol_data(input.clone()).unwrap();
    let version = u32::from_le_bytes(
        bytes[VERSION_OFFSET..VERSION_OFFSET + 4]
            .try_into()
            .unwrap(),
    );
    assert_eq!(version, 2);
    assert_eq!(bytes[COMPRESSION_OFFSET], 1); // zstd

    let uncompressed = write_symbol_data_uncompressed(input.clone()).unwrap();
    assert_eq!(
        symbol_data_known_decompressed_size(&bytes).unwrap(),
        Some(uncompressed.len() - COMPRESSION_OFFSET - 1)
    );

    let output = read_symbol_data::<SourceAndMap>(&bytes).unwrap();
    assert_eq!(input, output);
}

#[test]
fn test_v2_compressed_size_includes_concatenated_frames() {
    let first = zstd::bulk::compress(b"first", 3).unwrap();
    let second_payload = vec![b'x'; 100_000];
    let second = zstd::bulk::compress(&second_payload, 3).unwrap();

    let mut bytes = write_symbol_data(SourceAndMap {
        minified_source: "source".to_string(),
        sourcemap: "map".to_string(),
    })
    .unwrap();
    bytes.truncate(COMPRESSION_OFFSET + 1);
    bytes.extend(first);
    bytes.extend(second);

    assert_eq!(
        symbol_data_known_decompressed_size(&bytes).unwrap(),
        Some(5 + second_payload.len())
    );
}

#[test]
fn test_v2_compressed_without_content_size() {
    let mut encoder = zstd::Encoder::new(Vec::new(), 3).unwrap();
    encoder.write_all(b"legacy payload").unwrap();
    let compressed = encoder.finish().unwrap();

    let mut bytes = write_symbol_data(SourceAndMap {
        minified_source: "source".to_string(),
        sourcemap: "map".to_string(),
    })
    .unwrap();
    bytes.truncate(COMPRESSION_OFFSET + 1);
    bytes.extend(compressed);

    assert_eq!(symbol_data_known_decompressed_size(&bytes).unwrap(), None);
}

#[test]
fn test_limited_read_stops_at_the_limit() {
    let limit = 1024;
    let at_limit = ElfDebugInfo {
        data: vec![0; limit],
    };
    let bytes = write_symbol_data(at_limit.clone()).unwrap();
    assert_eq!(
        read_symbol_data_with_byte_count_limited::<ElfDebugInfo>(&bytes, limit).unwrap(),
        (at_limit, limit)
    );

    let over_limit = write_symbol_data(ElfDebugInfo {
        data: vec![0; limit + 1],
    })
    .unwrap();
    let uncompressed_over_limit = write_symbol_data_uncompressed(ElfDebugInfo {
        data: vec![0; limit + 1],
    })
    .unwrap();

    // A frame that declares no content size decodes until the frame ends.
    let mut encoder = zstd::Encoder::new(Vec::new(), 3).unwrap();
    encoder.write_all(&vec![0; 64 * limit]).unwrap();
    let mut undeclared_size = write_symbol_data(ElfDebugInfo { data: Vec::new() }).unwrap();
    undeclared_size.truncate(COMPRESSION_OFFSET + 1);
    undeclared_size.extend(encoder.finish().unwrap());

    for bytes in [over_limit, uncompressed_over_limit, undeclared_size] {
        assert_eq!(
            read_symbol_data_with_byte_count_limited::<ElfDebugInfo>(&bytes, limit).unwrap_err(),
            SymbolDataError::DecompressedTooLarge(limit as u64)
        );
    }
}

#[test]
fn test_v2_uncompressed_header() {
    let input = SourceAndMap {
        minified_source: "minified_source".to_string(),
        sourcemap: "sourcemap".to_string(),
    };

    let bytes = write_symbol_data_uncompressed(input.clone()).unwrap();
    let version = u32::from_le_bytes(
        bytes[VERSION_OFFSET..VERSION_OFFSET + 4]
            .try_into()
            .unwrap(),
    );
    assert_eq!(version, 2);
    assert_eq!(bytes[COMPRESSION_OFFSET], 0); // none

    let output = read_symbol_data::<SourceAndMap>(&bytes).unwrap();
    assert_eq!(input, output);
}

macro_rules! roundtrip_test {
    ($name:ident, $ty:ty, $value:expr) => {
        #[test]
        fn $name() {
            let input = $value;
            let bytes = write_symbol_data(input.clone()).unwrap();
            let output = read_symbol_data::<$ty>(&bytes).unwrap();
            assert_eq!(input, output);
        }
    };
}

roundtrip_test!(
    test_v2_roundtrip_source_and_map,
    SourceAndMap,
    SourceAndMap {
        minified_source: "minified_source".to_string(),
        sourcemap: "sourcemap".to_string(),
    }
);
roundtrip_test!(
    test_v2_roundtrip_hermes_map,
    HermesMap,
    HermesMap {
        sourcemap: "hermes map data".to_string(),
    }
);
roundtrip_test!(
    test_v2_roundtrip_proguard_mapping,
    ProguardMapping,
    ProguardMapping {
        content: "proguard mapping data".to_string(),
    }
);
roundtrip_test!(
    test_v2_roundtrip_elf_debug_info,
    ElfDebugInfo,
    ElfDebugInfo {
        data: b"\x7fELF fake debug payload".to_vec(),
    }
);

#[test]
fn test_cross_type_reads_fail() {
    // Consumers that accept multiple container types dispatch on the type tag,
    // so a type mismatch must be an error rather than a silent
    // reinterpretation — in both directions.
    let elf_bytes = write_symbol_data(ElfDebugInfo {
        data: b"\x7fELF fake debug payload".to_vec(),
    })
    .unwrap();
    assert!(read_symbol_data::<AppleDsym>(&elf_bytes).is_err());

    let dsym_bytes = write_symbol_data(AppleDsym {
        data: b"fake dsym zip payload".to_vec(),
    })
    .unwrap();
    assert!(read_symbol_data::<ElfDebugInfo>(&dsym_bytes).is_err());
}

#[test]
fn test_v2_compressed_large_payload() {
    let large_source = "a".repeat(100_000);
    let large_map = "b".repeat(100_000);
    let input = SourceAndMap {
        minified_source: large_source,
        sourcemap: large_map,
    };

    let bytes = write_symbol_data(input.clone()).unwrap();
    let uncompressed_bytes = write_symbol_data_uncompressed(input.clone()).unwrap();
    assert!(bytes.len() < uncompressed_bytes.len() / 2);

    let output = read_symbol_data::<SourceAndMap>(&bytes).unwrap();
    assert_eq!(input, output);
}