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)); }