Beispiel #1
0
        public void EmptyTracestate(string tracestate)
        {
            var tracestateEntries = new List <KeyValuePair <string, string> >();

            Assert.False(TracestateUtils.AppendTracestate(tracestate, tracestateEntries));
            Assert.Empty(tracestateEntries);
        }
Beispiel #2
0
        public void InvalidTracestate(string tracestate, int validEntriesCount)
        {
            var tracestateEntries = new List <KeyValuePair <string, string> >();

            Assert.False(TracestateUtils.AppendTracestate(tracestate, tracestateEntries));
            Assert.Equal(validEntriesCount, tracestateEntries.Count);
        }
Beispiel #3
0
        public void ValidPair(string pair)
        {
            var tracestateEntries = new List <KeyValuePair <string, string> >();

            Assert.True(TracestateUtils.AppendTracestate(pair, tracestateEntries));
            Assert.Single(tracestateEntries);
            Assert.Equal(new KeyValuePair <string, string>("k", "v"), tracestateEntries.Single());
            Assert.Equal("k=v", TracestateUtils.GetString(tracestateEntries));
        }
Beispiel #4
0
        public void TooManyEntries()
        {
            var tracestateEntries = new List <KeyValuePair <string, string> >();
            var tracestate        =
                "k0=v,k1=v,k2=v,k3=v,k4=v,k5=v,k6=v,k7=v1,k8=v,k9=v,k10=v,k11=v,k12=v,k13=v,k14=v,k15=v,k16=v,k17=v,k18=v,k19=v,k20=v,k21=v,k22=v,k23=v,k24=v,k25=v,k26=v,k27=v1,k28=v,k29=v,k30=v,k31=v,k32=v";

            Assert.False(TracestateUtils.AppendTracestate(tracestate, tracestateEntries));
            Assert.Empty(tracestateEntries);
        }
Beispiel #5
0
        public void ValidPair(string pair, string expectedKey, string expectedValue)
        {
            var tracestateEntries = new List <KeyValuePair <string, string> >();

            Assert.True(TracestateUtils.AppendTracestate(pair, tracestateEntries));
            Assert.Single(tracestateEntries);
            Assert.Equal(new KeyValuePair <string, string>(expectedKey, expectedValue), tracestateEntries.Single());
            Assert.Equal($"{expectedKey}={expectedValue}", TracestateUtils.GetString(tracestateEntries));
        }
Beispiel #6
0
        public void ValidPairs(string tracestate)
        {
            var tracestateEntries = new List <KeyValuePair <string, string> >();

            Assert.True(TracestateUtils.AppendTracestate(tracestate, tracestateEntries));
            Assert.Equal(2, tracestateEntries.Count);
            Assert.Contains(new KeyValuePair <string, string>("k1", "v1"), tracestateEntries);
            Assert.Contains(new KeyValuePair <string, string>("k2", "v2"), tracestateEntries);

            Assert.Equal("k1=v1,k2=v2", TracestateUtils.GetString(tracestateEntries));
        }
Beispiel #7
0
        public void MaxEntries()
        {
            var tracestateEntries = new List <KeyValuePair <string, string> >();
            var tracestate        =
                "k0=v,k1=v,k2=v,k3=v,k4=v,k5=v,k6=v,k7=v1,k8=v,k9=v,k10=v,k11=v,k12=v,k13=v,k14=v,k15=v,k16=v,k17=v,k18=v,k19=v,k20=v,k21=v,k22=v,k23=v,k24=v,k25=v,k26=v,k27=v1,k28=v,k29=v,k30=v,k31=v";

            Assert.True(TracestateUtils.AppendTracestate(tracestate, tracestateEntries));
            Assert.Equal(32, tracestateEntries.Count);
            Assert.Equal("k0=v,k1=v,k2=v,k3=v,k4=v,k5=v,k6=v,k7=v1,k8=v,k9=v,k10=v,k11=v,k12=v,k13=v,k14=v,k15=v,k16=v,k17=v,k18=v,k19=v,k20=v,k21=v,k22=v,k23=v,k24=v,k25=v,k26=v,k27=v1,k28=v,k29=v,k30=v,k31=v",
                         TracestateUtils.GetString(tracestateEntries));
        }
Beispiel #8
0
        private static ActivityAndTracestate FromActivity(string spanName, Activity activity)
        {
            List <KeyValuePair <string, string> > tracestate = null;

            if (activity.TraceStateString != null)
            {
                tracestate = new List <KeyValuePair <string, string> >();
                TracestateUtils.AppendTracestate(activity.TraceStateString, tracestate);
            }

            return(new ActivityAndTracestate(activity, tracestate));
        }
Beispiel #9
0
        private static ActivityAndTracestate FromCurrentParentActivity(string spanName, Activity current)
        {
            var activity = new Activity(spanName);

            activity.SetIdFormat(ActivityIdFormat.W3C);

            activity.Start();
            Activity.Current = current;

            List <KeyValuePair <string, string> > tracestate = null;

            if (activity.TraceStateString != null)
            {
                tracestate = new List <KeyValuePair <string, string> >();
                TracestateUtils.AppendTracestate(activity.TraceStateString, tracestate);
            }

            return(new ActivityAndTracestate(activity, tracestate));
        }
        private static SpanContext ParentContextFromActivity(Activity activity)
        {
            if (activity.TraceId != default && activity.ParentSpanId != default)
            {
                List <KeyValuePair <string, string> > tracestate = null;

                if (!string.IsNullOrEmpty(activity.TraceStateString))
                {
                    tracestate = new List <KeyValuePair <string, string> >();
                    TracestateUtils.AppendTracestate(activity.TraceStateString, tracestate);
                }

                return(new SpanContext(
                           activity.TraceId,
                           activity.ParentSpanId,
                           ActivityTraceFlags.Recorded,
                           tracestate));
            }

            return(null);
        }
        /// <inheritdoc/>
        public ISpan StartSpan()
        {
            var activityForSpan = this.CreateActivityForSpan(this.contextSource, this.parentSpan,
                                                             this.parentSpanContext, this.parentActivity, this.fromActivity);

            if (this.startTimestamp == default)
            {
                this.startTimestamp = new DateTimeOffset(activityForSpan.StartTimeUtc);
            }

            bool sampledIn = MakeSamplingDecision(
                this.parentSpanContext, // it is updated in CreateActivityForSpan
                this.name,
                this.sampler,
                this.links,
                activityForSpan.TraceId,
                activityForSpan.SpanId,
                this.tracerConfiguration);

            if (sampledIn || this.recordEvents)
            {
                activityForSpan.ActivityTraceFlags |= ActivityTraceFlags.Recorded;
            }
            else
            {
                activityForSpan.ActivityTraceFlags &= ~ActivityTraceFlags.Recorded;
            }

            var childTracestate = Enumerable.Empty <KeyValuePair <string, string> >();

            if (this.parentSpanContext != null && this.parentSpanContext.IsValid)
            {
                if (this.parentSpanContext.Tracestate != null &&
                    this.parentSpanContext.Tracestate.Any())
                {
                    childTracestate = this.parentSpanContext.Tracestate;
                }
            }
            else if (activityForSpan.TraceStateString != null)
            {
                var tracestate = new List <KeyValuePair <string, string> >();
                if (TracestateUtils.AppendTracestate(activityForSpan.TraceStateString, tracestate))
                {
                    childTracestate = tracestate;
                }
            }

            var span = new Span(
                activityForSpan,
                childTracestate,
                this.kind,
                this.tracerConfiguration,
                this.spanProcessor,
                this.startTimestamp,
                ownsActivity: this.contextSource != ContextSource.Activity,
                this.libraryResource);

            if (activityForSpan.OperationName != this.name)
            {
                span.UpdateName(this.name);
            }

            LinkSpans(span, this.links);
            return(span);
        }