Reuse TMemoryBuffer when calculating size of ThriftType (#185)

Previous approach allocates several max size buffer everytime we
want to calculate the size of the serialized thrift type. This changes
to reuse only 1 buffer per sender. As sender is single-threaded this should be
safe.

Signed-off-by: Daniel Dao <[email protected]>

Author: dqminh

src/jaegertracing/ThriftSender.cpp

@@ -39,19 +39,6 @@ namespace {
 
 constexpr auto kEmitBatchOverhead = 30;
 
-template <typename ThriftType>
-int calcSizeOfSerializedThrift(apache::thrift::protocol::TProtocolFactory& factory, const ThriftType& base, int maxPacketSize)
-{
-    std::shared_ptr<apache::thrift::transport::TMemoryBuffer> buffer(
-        new apache::thrift::transport::TMemoryBuffer(maxPacketSize));
-    auto protocol = factory.getProtocol(buffer);
-    base.write(protocol.get());
-    uint8_t* data = nullptr;
-    uint32_t size = 0;
-    buffer->getBuffer(&data, &size);
-    return size;
-}
-
 }  // anonymous namespace
 
 ThriftSender::ThriftSender(std::unique_ptr<utils::Transport>&& transporter)
@@ -60,6 +47,7 @@ ThriftSender::ThriftSender(std::unique_ptr<utils::Transport>&& transporter)
     , _byteBufferSize(0)
     , _processByteSize(0)
     , _protocolFactory(_transporter->protocolFactory())
+    , _thriftBuffer(new apache::thrift::transport::TMemoryBuffer())
 {
 }
 
@@ -82,15 +70,13 @@ int ThriftSender::append(const Span& span)
                        });
         _process.__set_tags(thriftTags);
 
-        _processByteSize =
-            calcSizeOfSerializedThrift(*_protocolFactory, _process, _transporter->maxPacketSize());
+        _processByteSize = calcSizeOfSerializedThrift(_process);
         _maxSpanBytes =
             _transporter->maxPacketSize() - _processByteSize - kEmitBatchOverhead;
     }
     thrift::Span jaegerSpan;
     span.thrift(jaegerSpan);
-    const auto spanSize =
-        calcSizeOfSerializedThrift(*_protocolFactory, jaegerSpan, _transporter->maxPacketSize());
+    const auto spanSize = calcSizeOfSerializedThrift(jaegerSpan);
     if (spanSize > _maxSpanBytes) {
         std::ostringstream oss;
         throw Sender::Exception("Span is too large", 1);

src/jaegertracing/ThriftSender.h

@@ -22,6 +22,7 @@
 #include "jaegertracing/Sender.h"
 #include "jaegertracing/thrift-gen/jaeger_types.h"
 #include "jaegertracing/utils/Transport.h"
+#include <thrift/transport/TBufferTransports.h>
 
 namespace jaegertracing {
 
@@ -50,13 +51,28 @@ class ThriftSender : public Sender {
         _byteBufferSize = _processByteSize;
     }
 
+    template <typename ThriftType>
+    int calcSizeOfSerializedThrift(const ThriftType& base)
+    {
+        _thriftBuffer->resetBuffer();
+        auto _protocol = _protocolFactory->getProtocol(_thriftBuffer);
+        base.write(_protocol.get());
+        uint8_t* data = nullptr;
+        uint32_t size = 0;
+        _thriftBuffer->getBuffer(&data, &size);
+        return size;
+    }
+
     std::unique_ptr<utils::Transport> _transporter;
     int _maxSpanBytes;
     int _byteBufferSize;
     std::vector<thrift::Span> _spanBuffer;
     thrift::Process _process;
     int _processByteSize;
     std::unique_ptr<apache::thrift::protocol::TProtocolFactory> _protocolFactory;
+    // reuse buffer across serializations of different ThriftType for size
+    // calculation
+    std::shared_ptr<apache::thrift::transport::TMemoryBuffer> _thriftBuffer;
 };
 
 }  // namespace jaegertracing