For incoming data you can grab the encoded buffer backing the RespMsg with getEncodedBuffer() then insert that into a binary log, e.g. GZIP-enabled Protobufs works well at 100k msg/s+ rates.

This buffer then would be independent of transforms and dictionary issues and can be re-decoded post-facto to replay any issues.

RFA/C++ example with SSL/Marketfeed into a Protobuf coded stream.

I'm posting as separate answer since comment legth restriction won't let me post the code sample. The main credit still goes to Steven McCoy.

Here is the hack code that I stitched together to copy the RFA Buffer without memory allocations. It relies on knowledge of internals of the Buffer implementation, however until there is some 'CopyTo' method, I guess that that's the only option.

public static class RfaBufferUtils
{
	public static unsafe void CopyRfaBufferToBuffer(ThomsonReuters.RFA.Common.Buffer rfaBuffer,
		byte[] destination, out int length)
	{
		length = 0;




		if(destination.Length < rfaBuffer.Size)
			throw new ArgumentException("Insufficient buffer");




		FieldInfo fi = typeof (ThomsonReuters.RFA.Common.Buffer).GetField("_Buffer",
			BindingFlags.NonPublic | BindingFlags.Instance);
		var bufferPtr = fi.GetValue(rfaBuffer);




		//rfa.common.Buffer* bufferPtr
		long pointrValue = *(long*) IntPtr.Add(((IntPtr) Pointer.Unbox(bufferPtr)), 8);
		if (pointrValue == 0L)
		{
			destination[0] = 0;
			return;
		}
		length = *(int*) IntPtr.Add(((IntPtr) Pointer.Unbox(bufferPtr)), 20);
		Marshal.Copy(new IntPtr((void*) pointrValue), destination, 0, length);
	}
}

This is how it can be called:

public void ProcessEvent(Event evt)
{
	RespMsg respMsg = (RespMsg)((OMMItemEvent)evt).Msg;
	long before = GC.GetTotalMemory(false);
	long length;
	RfaBufferUtils.CopyRfaBufferToBuffer(respMsg.EncodedBuffer, _preallocatedByteArray, out length);
	long after = GC.GetTotalMemory(false);
	Debug.Assert(after - before == 0);
	
	// Store the _preallocatedByteArray content as needed
	
	//...
}