I can lookup how big a value is by calling <https://doc.rust-lang.org/std/mem/fn.size_of_val.html>. This does not work well (in my case) for `vec`'s since the size is always 32 when not dereferencing, no matter how many elements.

I added some code below, I would expect that the amount of bytes of the `Incoming` `struct` is at least as large as the bytes for variable `vec`, because the `Incoming` `struct` holds the `vec`.

Deferencing the `vec` directly when calling `size_of_val` gives me the correct size of `vec`, but I am unable to do something similar for a type that holds a `vec`.

```
use std::mem::size_of_val;

#[derive(Debug)]
enum Incoming {
    Bytes(Vec<u8>),
    SomethingElse(String),
    Fixed(i64)
}

fn main() {
    let vec = vec![1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3];

    // 39
    println!("Vec's real size: {} bytes", size_of_val(&*vec));

    let incoming = Incoming::Bytes(vec);
    let size_of = size_of_val(&incoming);

    // 32
    println!("But incoming tells me it's size is {} bytes", size_of);
}

```

Is it possible to get the allocated memory for a type that holds a `vec`?

Usecase: `Incoming` represents all different requests my Rust server will handle. I want to Debug log every request. Some requests can contain `Vec<u8>` with many elements. In that case, I don't want to log that request because it literally takes minutes to it.