public async void AppendAsync_ShouldFlushWhenOverTheBufferSize()
{
var span = Substitute.For <ILetsTraceSpan>();
var tracer = Substitute.For <ILetsTraceTracer>();
span.Tracer.Returns(tracer);
var cts = new CancellationTokenSource();
var jProcess = Substitute.For <JaegerProcess>();
_mockJaegerThriftSerialization.BuildJaegerProcessThrift(Arg.Is(tracer)).Returns(jProcess);
var jSpan = Substitute.For <JaegerSpan>();
_mockJaegerThriftSerialization.BuildJaegerThriftSpan(Arg.Is(span)).Returns(jSpan);
_mockSender.BufferItem(Arg.Is(jSpan)).Returns(5);
_mockSender.FlushAsync(Arg.Any <JaegerProcess>(), Arg.Any <CancellationToken>()).Returns(5);
var sent = await _testingTransport.AppendAsync(span, cts.Token);
Assert.Equal(5, sent);
_mockJaegerThriftSerialization.Received(1).BuildJaegerProcessThrift(Arg.Is(tracer));
_mockJaegerThriftSerialization.Received(1).BuildJaegerThriftSpan(Arg.Is(span));
_mockSender.Received(1).BufferItem(Arg.Is(jSpan));
await _mockSender.Received(1).FlushAsync(Arg.Any <JaegerProcess>(), Arg.Any <CancellationToken>());
}
public async void FlushAsync_ShouldCallSenderAndReturnSentCount()
{
var cts = new CancellationTokenSource();
_mockSender.FlushAsync(Arg.Any <JaegerProcess>(), Arg.Any <CancellationToken>()).Returns(3);
var sent = await _testingTransport.FlushAsync(cts.Token);
Assert.Equal(3, sent);
await _mockSender.Received(1).FlushAsync(Arg.Any <JaegerProcess>(), Arg.Any <CancellationToken>());
}
public async void AppendAsync_ShouldAddSpanToSenderAndFlushWhenItFitsJustRight()
{
var maxPacketSize = _jSpanSize + _jProcessSize + TransportConstants.UdpEmitBatchOverhead;
var testingTransport = NewUdpTransportWithMaxPacketSize(maxPacketSize);
_mockSender.FlushAsync(Arg.Any <JaegerProcess>(), Arg.Any <CancellationToken>()).Returns(1);
var sent = await testingTransport.AppendAsync(Substitute.For <IJaegerCoreSpan>(), CancellationToken.None);
Assert.Equal(1, sent);
_mockSender.Received(1).BufferItem(Arg.Any <JaegerSpan>());
await _mockSender.Received(1).FlushAsync(Arg.Any <JaegerProcess>(), Arg.Any <CancellationToken>());
}
public async Task <int> AppendAsync(ILetsTraceSpan span, CancellationToken canellationToken)
{
if (_process == null)
{
_process = _jaegerThriftSerialization.BuildJaegerProcessThrift(span.Tracer);
}
var jaegerSpan = _jaegerThriftSerialization.BuildJaegerThriftSpan(span);
var curBuffCount = _sender.BufferItem(jaegerSpan);
if (curBuffCount > BufferSize)
{
return(await _sender.FlushAsync(_process, canellationToken));
}
return(0);
}
/// <summary>
/// FlushAsync flushes the sender buffer without checking to see if the sender has
/// reached the point at which we would normally flush.
/// </summary>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <int> FlushAsync(CancellationToken cancellationToken)
{
var sentCount = 0;
try
{
sentCount = await _sender.FlushAsync(_process, cancellationToken);
}
catch (Exception e)
{
throw new SenderException("Failed to flush spans.", e, sentCount);
}
return(sentCount);
}
async Task FlushAsync(CancellationToken cancellation)
{
try
{
var flushed = await sender.FlushAsync(cancellation);
Interlocked.Exchange(ref flush, 0);
metrics.ReporterSuccess(delta: flushed);
}
catch (SenderException ex)
{
metrics.ReporterFailure(delta: ex.DroppedSpanCount);
}
catch (Exception)
{
//log this and continue
}
}