The native value type

No data type in the default build

// trafikey — the module declaration: the list of data types is empty
valkey_module! {
    name: "trafikey",
    version: 100,
    allocator: (ValkeyAlloc, ValkeyAlloc),
    data_types: [],
    preload: preload,
    init: init,
    commands: [],
}

In the default build the server owns every value; the module owns commands, a C table and three Lua sources.

Off by default

# trafikey — Cargo.toml, the feature table and the closing comment
[features]
# the persistence probe for a module data type, never part of a shipped artifact;
# no default feature is declared, so a plain build leaves it off
probe-type = []
# …
# The cdylib is loaded by Valkey; no standalone RESP listener or bitmap data type is implemented here.

# deploy — build-local.sh, the build line: the package, no feature flag
cargo build --locked --release -p trafikey

// trafikey — lib.rs: the probe module and init's first step, both under the feature
mod emq;
#[cfg(feature = "probe-type")]
mod probe_type;
mod registry;
mod tra;
// …
fn init(ctx: &Context, _: &[ValkeyString]) -> Status {
    #[cfg(feature = "probe-type")]
    if probe_type::PROBE_TYPE.create_data_type(ctx.ctx).is_err() {
        return Status::Err;
    }
    // … every later step of init, the shared API export last
    Status::Ok
}

// trafikey — registry::TABLE, the two probe rows: family Probe, no capability token
    #[cfg(feature = "probe-type")]
    probe_set => crate::probe_type::set, Row { name: c"TRAPROBE.SET", family: Family::Probe, arity: 3,
        flags: "write deny-oom", keys: &[Keys { flags: &["READ_WRITE", "UPDATE"], index: 1, find: ARGV1 }],
        acl: c"write slow", caps: &[], summary: None, complexity: None, since: None };
    #[cfg(feature = "probe-type")]
    probe_get => crate::probe_type::get, Row { name: c"TRAPROBE.GET", family: Family::Probe, arity: 2,
        flags: "readonly fast", keys: &[Keys { flags: &["READ_ONLY", "ACCESS"], index: 1, find: ARGV1 }],
        acl: c"read fast", caps: &[], summary: None, complexity: None, since: None };

One feature switches the probe on in three places at once, and nothing in the repository’s build switches it on.

Four callbacks, two commands

// trafikey — probe_type: the traprobe1 type and its four callbacks
pub struct Probe(Vec<u8>);

pub static PROBE_TYPE: ValkeyType = ValkeyType::new(
    "traprobe1",
    0,
    raw::RedisModuleTypeMethods {
        version: raw::REDISMODULE_TYPE_METHOD_VERSION as u64,
        rdb_load: Some(rdb_load),
        rdb_save: Some(rdb_save),
        aof_rewrite: Some(aof_rewrite),
        free: Some(free),
        digest: None,
        mem_usage: None,
        // … aux_*, free_effort, unlink, copy, defrag and the rest: None or 0
    },
);

unsafe extern "C" fn rdb_load(rdb: *mut raw::RedisModuleIO, encver: c_int) -> *mut c_void {
    if encver != 0 {
        return std::ptr::null_mut();
    }
    match raw::load_string_buffer(rdb) {
        Ok(buffer) => Box::into_raw(Box::new(Probe(buffer.as_ref().to_vec()))).cast(),
        Err(_) => std::ptr::null_mut(),
    }
}
unsafe extern "C" fn rdb_save(rdb: *mut raw::RedisModuleIO, value: *mut c_void) {
    raw::save_slice(rdb, unsafe { &(*value.cast::<Probe>()).0 });
}
unsafe extern "C" fn aof_rewrite(
    aof: *mut raw::RedisModuleIO,
    key: *mut raw::RedisModuleString,
    value: *mut c_void,
) {
    let bytes = unsafe { &(*value.cast::<Probe>()).0 };
    #[expect(
        clippy::unwrap_used,
        reason = "the preload gate refuses the load without EmitAOF; aof_rewrite has no error channel"
    )]
    unsafe {
        raw::RedisModule_EmitAOF.unwrap()(
            aof,
            c"TRAPROBE.SET".as_ptr(),
            c"sb".as_ptr(),
            key,
            bytes.as_ptr(),
            bytes.len(),
        );
    }
}
unsafe extern "C" fn free(value: *mut c_void) {
    drop(unsafe { Box::from_raw(value.cast::<Probe>()) });
}

// trafikey — probe_type: TRAPROBE.SET and TRAPROBE.GET
pub(crate) fn set(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
    // The host enforces arity 3 before the handler runs; the else arm is its arity reply.
    let [_, name, payload] = args.as_slice() else {
        return Err(ValkeyError::WrongArity);
    };
    ctx.open_key_writable(name)
        .set_value(&PROBE_TYPE, Probe(payload.as_slice().to_vec()))?;
    ctx.replicate_verbatim();
    Ok(ValkeyValue::SimpleStringStatic("OK"))
}
pub(crate) fn get(ctx: &Context, args: Vec<ValkeyString>) -> ValkeyResult {
    // The host enforces arity 2 before the handler runs; the else arm is its arity reply.
    let [_, name] = args.as_slice() else {
        return Err(ValkeyError::WrongArity);
    };
    Ok(match ctx.open_key(name).get_value::<Probe>(&PROBE_TYPE)? {
        Some(probe) => ValkeyValue::StringBuffer(probe.0.clone()),
        None => ValkeyValue::Null,
    })
}

The probe proves the mechanism, a module value through RDB, AOF and a restart; it carries no bitmap and ships in no artifact.

Pattern & implementation

This dive closes the module. Return to the hub for the whole family in one picture, or go on to the workshop.

References