public void Trace_MultipleSpans()
{
string rootSpanName = EntryData.GetMessage(nameof(Trace_MultipleSpans), _testId);
var labels = new Dictionary <string, string>
{
{ "annotation-key", "annotation-value" }
};
var tracer = CreateSimpleManagedTracer(_grpcConsumer);
using (tracer.StartSpan(rootSpanName))
{
BlockUntilClockTick();
using (tracer.StartSpan("child-one"))
{
tracer.SetStackTrace(TraceEntryData.CreateStackTrace());
BlockUntilClockTick();
}
using (tracer.StartSpan("child-two"))
{
BlockUntilClockTick();
using (tracer.StartSpan("grandchild-one", StartSpanOptions.Create(SpanKind.RpcClient)))
{
BlockUntilClockTick();
}
using (tracer.StartSpan("grandchild-two"))
{
BlockUntilClockTick();
tracer.AnnotateSpan(labels);
}
}
}
TraceProto trace = TraceEntryPolling.Default.GetTrace(rootSpanName, _startTime);
Assert.NotNull(trace);
Assert.Equal(5, trace.Spans.Count);
TraceSpan root = trace.Spans.First(s => s.Name.Equals(rootSpanName));
TraceSpan childOne = trace.Spans.First(s => s.Name.Equals("child-one"));
TraceSpan childTwo = trace.Spans.First(s => s.Name.Equals("child-two"));
TraceSpan grandchildOne = trace.Spans.First(s => s.Name.Equals("grandchild-one"));
TraceSpan grandchildTwo = trace.Spans.First(s => s.Name.Equals("grandchild-two"));
Assert.Equal(root.SpanId, childOne.ParentSpanId);
TraceEntryVerifiers.AssertContainsStackTrace(childOne,
nameof(TraceEntryData.CreateStackTrace), nameof(SimpleManagedTracerTest));
Assert.Equal(root.SpanId, childTwo.ParentSpanId);
Assert.Equal(childTwo.SpanId, grandchildOne.ParentSpanId);
Assert.Equal(TraceSpan.Types.SpanKind.RpcClient, grandchildOne.Kind);
Assert.Equal(childTwo.SpanId, grandchildTwo.ParentSpanId);
Assert.Equal(TraceSpan.Types.SpanKind.Unspecified, grandchildTwo.Kind);
TraceEntryVerifiers.AssertSpanLabelsExact(grandchildTwo, labels);
}
public void Trace_MultipleSpans()
{
string rootSpanName = CreateRootSpanName(nameof(Trace_MultipleSpans));
var consumer = CreateGrpcTraceConsumer();
var tracer = CreateSimpleManagedTracer(consumer);
var annotation = new Dictionary <string, string>
{
{ "annotation-key", "annotation-value" }
};
tracer.StartSpan(rootSpanName);
BlockUntilClockTick();
tracer.StartSpan("child-one");
tracer.SetStackTrace(new StackTrace(CreateException(), true));
BlockUntilClockTick();
tracer.EndSpan();
tracer.StartSpan("child-two");
BlockUntilClockTick();
tracer.StartSpan("grandchild-one", StartSpanOptions.Create(SpanKind.RpcClient));
BlockUntilClockTick();
tracer.EndSpan();
tracer.StartSpan("grandchild-two");
BlockUntilClockTick();
tracer.AnnotateSpan(annotation);
tracer.EndSpan();
tracer.EndSpan();
tracer.EndSpan();
TraceProto trace = _polling.GetTrace(rootSpanName, _startTime);
Assert.NotNull(trace);
Assert.Equal(5, trace.Spans.Count);
TraceSpan root = trace.Spans.First(s => s.Name.Equals(rootSpanName));
TraceSpan childOne = trace.Spans.First(s => s.Name.Equals("child-one"));
TraceSpan childTwo = trace.Spans.First(s => s.Name.Equals("child-two"));
TraceSpan grandchildOne = trace.Spans.First(s => s.Name.Equals("grandchild-one"));
TraceSpan grandchildTwo = trace.Spans.First(s => s.Name.Equals("grandchild-two"));
Assert.Equal(root.SpanId, childOne.ParentSpanId);
var labels = childOne.Labels;
Assert.True(labels.ContainsKey(TraceLabels.StackTrace));
Assert.Contains(nameof(CreateException), labels[TraceLabels.StackTrace]);
Assert.Contains(nameof(SimpleManagedTracerTest), labels[TraceLabels.StackTrace]);
Assert.Equal(root.SpanId, childTwo.ParentSpanId);
Assert.Equal(childTwo.SpanId, grandchildOne.ParentSpanId);
Assert.Equal(TraceSpan.Types.SpanKind.RpcClient, grandchildOne.Kind);
Assert.Equal(childTwo.SpanId, grandchildTwo.ParentSpanId);
Assert.Equal(TraceSpan.Types.SpanKind.Unspecified, grandchildTwo.Kind);
Assert.True(TraceUtils.IsValidAnnotation(grandchildTwo, annotation));
}
public void SingleSpan_Options()
{
var mockConsumer = new Mock <IConsumer <TraceProto> >();
var tracer = SimpleManagedTracer.Create(mockConsumer.Object, CreateTrace());
mockConsumer.Setup(c => c.Receive(
Match.Create <IEnumerable <TraceProto> >(
t => IsValidSpan(t.Single().Spans.Single(), "span-name", 0, SpanKind.RpcClient))));
var options = StartSpanOptions.Create(SpanKind.RpcClient);
tracer.StartSpan("span-name", options);
tracer.EndSpan();
mockConsumer.VerifyAll();
}
public ISpan StartSpan(string operationName, StartSpanOptions startSpanOptions)
{
ISpan span;
var rootSpanContext = _spanContextFactory.NewRootSpanContext();
span = NewSpan(rootSpanContext, operationName, startSpanOptions.StartTime, startSpanOptions.References);
foreach (var tag in startSpanOptions.Tag)
{
span.SetTag(tag.Key, tag.Value);
}
return(span);
}
public void SingleSpan_Options()
{
var mockConsumer = new Mock <IConsumer <TraceProto> >();
var tracer = SimpleManagedTracer.Create(mockConsumer.Object, ProjectId, TraceId);
var annotation = new Dictionary <string, string>();
annotation.Add("annotation-key", "annotation-value");
mockConsumer.Setup(c => c.Receive(
Match.Create <IEnumerable <TraceProto> >(
t => IsValidSpan(t.Single().Spans.Single(), "span-name", 0, SpanKind.RpcClient) &&
TraceUtils.IsValidAnnotation(t.ElementAt(0).Spans[0], annotation))));
var options = StartSpanOptions.Create(SpanKind.RpcClient, annotation);
tracer.StartSpan("span-name", options).Dispose();
mockConsumer.VerifyAll();
}
public void MultipleSpans()
{
var mockConsumer = new Mock <IConsumer <TraceProto> >();
var tracer = SimpleManagedTracer.Create(mockConsumer.Object, ProjectId, TraceId);
var annotation = new Dictionary <string, string>();
annotation.Add("annotation-key", "annotation-value");
Predicate <IEnumerable <TraceProto> > matcher = t =>
{
var spans = t.Single().Spans;
return(spans.Count == 5 &&
IsValidSpan(spans[0], "child-one", spans[4].SpanId) &&
IsValidSpan(spans[1], "grandchild-one", spans[3].SpanId, SpanKind.RpcClient) &&
IsValidSpan(spans[2], "grandchild-two", spans[3].SpanId) &&
TraceUtils.IsValidAnnotation(spans[2], annotation) &&
IsValidSpan(spans[3], "child-two", spans[4].SpanId) &&
!string.IsNullOrWhiteSpace(spans[0].Labels[TraceLabels.StackTrace]) &&
IsValidSpan(spans[4], "root"));
};
mockConsumer.Setup(c => c.Receive(Match.Create(matcher)));
using (tracer.StartSpan("root"))
{
using (tracer.StartSpan("child-one"))
{
tracer.SetStackTrace(FilledStackTrace);
}
using (tracer.StartSpan("child-two"))
{
using (tracer.StartSpan("grandchild-one", StartSpanOptions.Create(SpanKind.RpcClient))) { }
using (tracer.StartSpan("grandchild-two"))
{
tracer.AnnotateSpan(annotation);
}
}
}
mockConsumer.VerifyAll();
}
public ISpan StartSpan(string name, StartSpanOptions options = null) => throw new NotImplementedException();
public void RunInSpan(Action action, string name, StartSpanOptions options = null)
{
_ranInSpans.Add(name);
action();
}
public T RunInSpan <T>(Func <T> func, string name, StartSpanOptions options = null)
{
_ranInSpans.Add(name);
return(func());
}
public async Task <T> RunInSpanAsync <T>(Func <Task <T> > func, string name, StartSpanOptions options = null)
{
_ranInSpans.Add(name);
return(await func());
}
public ISpan StartSpan(string operationName, StartSpanOptions startSpanOptions)
{
return(_spanFactory.StartSpan(operationName, startSpanOptions));
}
