I'm pretty convinced the design was right, but I ran out of motivation before finishing the implementation
The general idea was to write a RT-safe logger by using abomonation to serialize logs into pre-allocated storage and deserialize them in place, as demonstrated here : https://github.com/HadrienG2/rt-logger/tree/master/src .
Which led me to do a lot of work on reducing UB in abomonation... that unfortunately never got merged due to lack of maintainer availability : https://github.com/TimelyDataflow/abomonation/pulls .
I was not happy about using fixed-size memory blocks for log storage as done in the archived version of rt-logger, because sometimes that was too much, and sometimes that was too little. Which also had a performance impact because I used a crossbeam channel, not a custom one. Which meant to move a full memory block into the channel on emission and move it out on reception, no matter how much of that block I was using. I could have resolved the latter problem by sending &'static references to statically allocated blocks around, but that would have meant using some kind of static mut storage, which meant writing some unsafe to avoid locks anyway, and it wouldn't have resolved the former problem of inadequate block size.
So I set out to write a realtime safe simple dynamic memory allocator that was suitable for this need: https://github.com/HadrienG2/bacara . The idea was then to modify rt-logger to allocate memory, serialize the input data in there, and send a pointer to that memory through the channel on message emission. Then, on emission, my custom channel would deserialize the data in place, pass a pointer to that to another callback, and deallocate the memory after the callback is over.
But I ran out of energy for doing this on my spare time at some point during the implementation of that allocator, more precisely while writing the unit tests before entering the performance testing phase.
I still have planning notes around if someone feels like taking this over, though.
But maybe for what you're doing, just using a bounded crossbeam channel directly would work just fine?