nautechsystems/nautilus_trader · error

Failed to serialize strings to JSON

Error message

Failed to serialize strings to JSON

What it means

Panic in `string_vec_to_bytes`: `serde_json::to_string(strings).expect("Failed to serialize strings to JSON")` aborts if JSON serialization of the string slice fails. In practice `serde_json` cannot fail serializing a `&[String]`, so this panic indicates an internal/unexpected condition (e.g. an incompatible serde_json feature set or a corrupted state) rather than caller input. Documented under the function's # Panics section.

Source

Thrown at crates/core/src/ffi/parsing.rs:84

    arr.iter()
        .map(|value| {
            value
                .as_str()
                .expect("C string JSON array must contain only strings")
                .to_owned()
        })
        .collect()
}

/// Convert a slice of `String` into a C string pointer (JSON encoded).
///
/// # Panics
///
/// Panics if JSON serialization fails or if the generated string contains interior null bytes.
#[must_use]
pub fn string_vec_to_bytes(strings: &[String]) -> *const c_char {
    let json_string = serde_json::to_string(strings).expect("Failed to serialize strings to JSON");
    let c_string = CString::new(json_string).expect("JSON string contains interior null bytes");

    c_string.into_raw()
}

/// Convert a C bytes pointer into an owned `Option<HashMap<String, Value>>`.
///
/// # Safety
///
/// Assumes `ptr` is a valid C string pointer.
///
/// # Panics
///
/// Panics if `ptr` is not null but contains invalid UTF-8 or JSON.
#[must_use]
pub unsafe fn optional_bytes_to_json(ptr: *const c_char) -> Option<HashMap<String, Value>> {
    // SAFETY: A non-null pointer is valid under the caller's contract
    unsafe { optional_json_from_cstr(ptr) }

View on GitHub (pinned to 18893faf8b)

Solutions

1. Verify serde_json is the standard, unmodified crate version per Cargo.lock (no patched forks)
2. Rebuild the crate; transient build/feature misconfigurations are the realistic cause
3. Check the input is a plain `&[String]` and no custom Serialize wrappers were introduced
4. If reproducible, file an issue — for `Vec<String>` this path is expected to be infallible

// serialization of &[String] via serde_json is infallible; verify dependency integrity instead
// cargo tree -i serde_json  # ensure no patched/forked serde_json

let result = std::panic::catch_unwind(|| string_vec_to_bytes(strings));
match result { Ok(p) => p, Err(_) => { eprintln!("string_vec_to_bytes panicked"); std::ptr::null() } }

When it happens

Trigger: Calling `string_vec_to_bytes` (directly or via `synthetic_instrument_components_to_cstr`) when `serde_json::to_string` returns an Err — an effectively unreachable path for plain string slices, kept as a fail-fast guard.

Common situations: Highly unusual: broken/custom serde_json builds, exotic `String` contents interacting with non-default serializer features, or future refactors changing the input type to something fallible to serialize.

Understand the failure class

Background: "JSON serialization failed", "not JSON serializable", "Failed to serialize": why JSON marshaling errors happen and how to fix them — this error's family across 46 libraries.

Related errors

• C string contains invalid JSON
• C string JSON must be an array of strings
• C string JSON array must contain only strings
• JSON string contains interior null bytes
• Invalid scientific notation exponent '{exponent}': must be a

AI-assisted analysis of nautechsystems/nautilus_trader@18893faf8b (2026-09-08). Data as JSON: /api/errors/bbb9287e6c7fbe13. Report an issue: GitHub.