Struct MemoryEvent 

pub struct MemoryEvent {

    pub timestamp: u64,
    pub event_type: MemoryEventType,
    pub ptr: usize,
    pub size: usize,
    pub old_size: Option<usize>,
    pub new_ptr: Option<usize>,
    pub binding_serial: Option<u64>,
    pub degraded_release: bool,
    pub charge_outcome: Option<ChargeOutcome>,
    pub thread_id: u64,
    pub var_name: Option<String>,
    pub type_name: Option<String>,
    pub call_stack_hash: Option<u64>,
    pub thread_name: Option<String>,
    pub source_file: Option<String>,
    pub source_line: Option<u32>,
    pub module_path: Option<String>,
    pub clone_source_ptr: Option<usize>,
    pub clone_target_ptr: Option<usize>,
    pub stack_ptr: Option<usize>,
    pub task_id: Option<u64>,
}

Unified memory event type

This structure captures all essential information about memory operations across all tracking backends (core, lockfree, async, unified).

Fields

timestamp: u64

Event timestamp (nanoseconds since epoch)

event_type: MemoryEventType

Event type

ptr: usize

Memory pointer address

size: usize

Allocation size in bytes

old_size: Option<usize>

Previous allocation size (for Reallocate events)

new_ptr: Option<usize>

New address (for Reallocate events that moved the block).

None means the block stayed at ptr; Some(new_ptr) means it migrated, so the old address binding must be closed and a new one opened.

binding_serial: Option<u64>

Capture-local binding identity, preserved across reallocation. Older event streams omit it and use address/size matching during replay.

degraded_release: bool

Set when a release could only be matched by address (the address held several live bindings), so the closed binding was chosen by policy rather than identified.

Carried by the event instead of only a counter: replay and every export can then say that this release is a lower bound of the evidence, not an exact fact.

charge_outcome: Option<ChargeOutcome>

Registry charge result captured before publishing an allocation. Missing on legacy streams and non-allocation events; replay must not replace it with live registry state.

thread_id: u64

Thread identifier

var_name: Option<String>

Optional variable name

type_name: Option<String>

Optional type name

call_stack_hash: Option<u64>

Optional call stack hash

thread_name: Option<String>

Optional thread name

source_file: Option<String>

Optional source file path

source_line: Option<u32>

Optional source line number

module_path: Option<String>

Optional module path

clone_source_ptr: Option<usize>

Clone source pointer (for Clone events)

clone_target_ptr: Option<usize>

Clone target pointer (for Clone events)

stack_ptr: Option<usize>

Stack pointer (for StackOwner types like Arc/Rc)

task_id: Option<u64>

Task ID (for task-aware memory tracking)

Implementations

impl MemoryEvent

pub fn allocate(ptr: usize, size: usize, thread_id: u64) -> Self

Create a new allocation event.

Constructing an event has no accounting side effect: task memory is recorded once at the capture site (see Tracker::track_inner), otherwise building an event — or replaying a recorded one — would double count.

pub fn reallocate_moved( ptr: usize, new_ptr: usize, old_size: usize, new_size: usize, thread_id: u64, ) -> Self

Create a migrating reallocation event.

reallocate() describes a block that stayed at ptr; this variant records that the allocator returned a different address, so reconstruction can close the old binding and open one at new_ptr.

pub fn deallocate(ptr: usize, size: usize, thread_id: u64) -> Self

Create a new deallocation event

pub fn reallocate( ptr: usize, old_size: usize, new_size: usize, thread_id: u64, ) -> Self

Create a new reallocation event

pub fn metadata( var_name: String, type_name: String, thread_id: u64, size: usize, ) -> Self

Create a new metadata event for Container/Value types (no heap allocation)

pub fn clone_event( source_ptr: usize, target_ptr: usize, size: usize, thread_id: u64, var_name: Option<String>, type_name: Option<String>, ) -> Self

Create a new clone event

pub fn borrow(ptr: usize, size: usize, thread_id: u64, is_mutable: bool) -> Self

Create a new borrow event

pub fn now() -> u64

Get current timestamp in nanoseconds Returns 0 if system time is before Unix epoch (should not happen in practice)

pub fn with_var_name(self, name: String) -> Self

Set variable name

pub fn with_type_name(self, name: String) -> Self

Set type name

pub fn with_source_file(self, file: String) -> Self

Set source file path

pub fn with_source_line(self, line: u32) -> Self

Set source line number

pub fn with_call_stack_hash(self, hash: u64) -> Self

Set call stack hash

pub fn with_thread_name(self, name: String) -> Self

Set thread name

pub fn is_allocation(&self) -> bool

Check if this is an allocation event

pub fn is_deallocation(&self) -> bool

Check if this is a deallocation event

pub fn is_move(&self) -> bool

Check if this is a move event

pub fn is_borrow(&self) -> bool

Check if this is a borrow event

pub fn is_return(&self) -> bool

Check if this is a return event

Trait Implementations

impl Clone for MemoryEvent

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MemoryEvent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MemoryEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&MemoryEvent> for DashboardEventDTO

fn from(e: &MemoryEvent) -> Self

Converts to this type from the input type.

impl Serialize for MemoryEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.