internal static ISpan StartSpan(
ISpanContext context,
SpanOptions options,
string name,
ISpanId parentSpanId,
bool?hasRemoteParent,
ITraceParams traceParams,
IStartEndHandler startEndHandler,
ITimestampConverter timestampConverter,
IClock clock
)
{
var span = new Span(
context,
options,
name,
parentSpanId,
hasRemoteParent,
traceParams,
startEndHandler,
timestampConverter,
clock);
// Call onStart here instead of calling in the constructor to make sure the span is completely
// initialized.
if (span.Options.HasFlag(SpanOptions.RECORD_EVENTS))
{
startEndHandler.OnStart(span);
}
return(span);
}
//public virtual void AddMessageEvent(MessageEventBase messageEvent)
//{
// Default implementation by invoking addNetworkEvent() so that any existing derived classes,
// including implementation and the mocked ones, do not need to override this method explicitly.
//addNetworkEvent(BaseMessageEventUtil.asNetworkEvent(messageEvent));
//}
//public abstract void AddLink(LinkBase link);
private Span(
ISpanContext context,
SpanOptions options,
string name,
ISpanId parentSpanId,
bool?hasRemoteParent,
ITraceParams traceParams,
IStartEndHandler startEndHandler,
ITimestampConverter timestampConverter,
IClock clock)
: base(context, options)
{
this.parentSpanId = parentSpanId;
this.hasRemoteParent = hasRemoteParent;
this.name = name;
this.traceParams = traceParams;
this.startEndHandler = startEndHandler;
this.clock = clock;
this.hasBeenEnded = false;
this.sampleToLocalSpanStore = false;
if (options.HasFlag(SpanOptions.RECORD_EVENTS))
{
this.timestampConverter = timestampConverter != null ? timestampConverter : Census.Internal.TimestampConverter.Now(clock);
startNanoTime = clock.NowNanos;
}
else
{
this.startNanoTime = 0;
this.timestampConverter = timestampConverter;
}
}
private Span(
ISpanContext context,
SpanOptions options,
string name,
ISpanId parentSpanId,
bool?hasRemoteParent,
ITraceParams traceParams,
IStartEndHandler startEndHandler,
ITimestampConverter timestampConverter,
IClock clock)
: base(context, options)
{
this.parentSpanId = parentSpanId;
this.hasRemoteParent = hasRemoteParent;
this.Name = name;
this.traceParams = traceParams ?? throw new ArgumentNullException(nameof(traceParams));
this.startEndHandler = startEndHandler;
this.clock = clock;
this.hasBeenEnded = false;
this.sampleToLocalSpanStore = false;
if (options.HasFlag(SpanOptions.RecordEvents))
{
this.timestampConverter = timestampConverter ?? OpenCensus.Internal.TimestampConverter.Now(clock);
this.startNanoTime = clock.NowNanos;
}
else
{
this.startNanoTime = 0;
this.timestampConverter = timestampConverter;
}
}
public void ConvertNanoTime()
{
mockClock.Setup(clock => clock.Now).Returns(timestamp);
mockClock.Setup(clock => clock.NowNanos).Returns(1234L);
ITimestampConverter timeConverter = TimestampConverter.Now(mockClock.Object);
Assert.Equal(Timestamp.Create(1234, 10678), timeConverter.ConvertNanoTime(6234));
Assert.Equal(Timestamp.Create(1234, 5444), timeConverter.ConvertNanoTime(1000));
Assert.Equal(Timestamp.Create(1235, 0), timeConverter.ConvertNanoTime(999995556));
}
//@Rule public readonly ExpectedException exception = ExpectedException.none();
public SpanTest()
{
spanContext = SpanContext.Create(TraceId.GenerateRandomId(random), SpanId.GenerateRandomId(random), TraceOptions.DEFAULT);
parentSpanId = SpanId.GenerateRandomId(random);
testClock = TestClock.Create(timestamp);
timestampConverter = TimestampConverter.Now(testClock);
attributes.Add(
"MyStringAttributeKey", AttributeValue.StringAttributeValue("MyStringAttributeValue"));
attributes.Add("MyLongAttributeKey", AttributeValue.LongAttributeValue(123L));
attributes.Add("MyBooleanAttributeKey", AttributeValue.BooleanAttributeValue(false));
expectedAttributes = new Dictionary <String, IAttributeValue>(attributes);
expectedAttributes.Add(
"MySingleStringAttributeKey",
AttributeValue.StringAttributeValue("MySingleStringAttributeValue"));
}
public override ISpan StartSpan()
{
ISpanContext parentContext = RemoteParentSpanContext;
bool hasRemoteParent = true;
ITimestampConverter timestampConverter = null;
if (RemoteParentSpanContext == null)
{
// This is not a child of a remote Span. Get the parent SpanContext from the parent Span if
// any.
ISpan parent = this.Parent;
hasRemoteParent = false;
if (parent != null)
{
parentContext = parent.Context;
// Pass the timestamp converter from the parent to ensure that the recorded events are in
// the right order. Implementation uses System.nanoTime() which is monotonically increasing.
if (parent is Span)
{
timestampConverter = ((Span)parent).TimestampConverter;
}
}
else
{
hasRemoteParent = false;
}
}
return(StartSpanInternal(
parentContext,
hasRemoteParent,
Name,
Sampler,
ParentLinks,
RecordEvents,
timestampConverter));
}
private static ITimedEvents <T> CreateTimedEvents <T>(TraceEvents <EventWithNanoTime <T> > events, ITimestampConverter timestampConverter)
{
if (events == null)
{
IList <ITimedEvent <T> > empty = new List <ITimedEvent <T> >();
return(TimedEvents <T> .Create(empty, 0));
}
IList <ITimedEvent <T> > eventsList = new List <ITimedEvent <T> >(events.Events.Count);
foreach (EventWithNanoTime <T> networkEvent in events.Events)
{
eventsList.Add(networkEvent.ToSpanDataTimedEvent(timestampConverter));
}
return(TimedEvents <T> .Create(eventsList, events.NumberOfDroppedEvents));
}
private ISpan StartSpanInternal(
ISpanContext parent,
bool hasRemoteParent,
string name,
ISampler sampler,
IList <ISpan> parentLinks,
bool recordEvents,
ITimestampConverter timestampConverter)
{
ITraceParams activeTraceParams = Options.TraceConfig.ActiveTraceParams;
IRandomGenerator random = Options.RandomHandler;
ITraceId traceId;
ISpanId spanId = SpanId.GenerateRandomId(random);
ISpanId parentSpanId = null;
TraceOptionsBuilder traceOptionsBuilder;
if (parent == null || !parent.IsValid)
{
// New root span.
traceId = TraceId.GenerateRandomId(random);
traceOptionsBuilder = TraceOptions.Builder();
// This is a root span so no remote or local parent.
//hasRemoteParent = null;
hasRemoteParent = false;
}
else
{
// New child span.
traceId = parent.TraceId;
parentSpanId = parent.SpanId;
traceOptionsBuilder = TraceOptions.Builder(parent.TraceOptions);
}
traceOptionsBuilder.SetIsSampled(
MakeSamplingDecision(
parent,
hasRemoteParent,
name,
sampler,
parentLinks,
traceId,
spanId,
activeTraceParams));
TraceOptions traceOptions = traceOptionsBuilder.Build();
SpanOptions spanOptions = SpanOptions.NONE;
if (traceOptions.IsSampled || recordEvents)
{
spanOptions = SpanOptions.RECORD_EVENTS;
}
ISpan span = Span.StartSpan(
SpanContext.Create(traceId, spanId, traceOptions),
spanOptions,
name,
parentSpanId,
hasRemoteParent,
activeTraceParams,
Options.StartEndHandler,
timestampConverter,
Options.Clock);
LinkSpans(span, parentLinks);
return(span);
}
internal ITimedEvent <T> ToSpanDataTimedEvent(ITimestampConverter timestampConverter)
{
return(TimedEvent <T> .Create(timestampConverter.ConvertNanoTime(this.nanoTime), this.@event));
}
