public Span(string operationName, DateTimeOffset startTimestamp, ISpanContext spanContext, ISpanRecorder spanRecorder) { _state = 0; _spanRecorder = spanRecorder ?? throw new ArgumentNullException(nameof(spanRecorder)); SpanContext = spanContext ?? throw new ArgumentNullException(nameof(spanContext)); Tags = new TagCollection(); Logs = new LogCollection(); OperationName = operationName; StartTimestamp = startTimestamp; }
public static ILink FromSpanContext(ISpanContext context, LinkType type, IDictionary <string, IAttributeValue> attributes) { IDictionary <string, IAttributeValue> copy = new Dictionary <string, IAttributeValue>(attributes); return(new Link( context.TraceId, context.SpanId, type, new ReadOnlyDictionary <string, IAttributeValue>(copy))); }
internal SpanData( ISpanContext context, ISpanId parentSpanId, bool?hasRemoteParent, string name, ITimestamp startTimestamp, IAttributes attributes, ITimedEvents <IAnnotation> annotations, ITimedEvents <IMessageEvent> messageEvents, ILinks links, int?childSpanCount, Status status, ITimestamp endTimestamp) { if (context == null) { throw new ArgumentNullException(nameof(context)); } this.Context = context; this.ParentSpanId = parentSpanId; this.HasRemoteParent = hasRemoteParent; if (name == null) { throw new ArgumentNullException(nameof(name)); } this.Name = name; if (startTimestamp == null) { throw new ArgumentNullException(nameof(startTimestamp)); } this.StartTimestamp = startTimestamp; if (attributes == null) { throw new ArgumentNullException(nameof(attributes)); } this.Attributes = attributes; if (annotations == null) { throw new ArgumentNullException(nameof(annotations)); } this.Annotations = annotations; if (messageEvents == null) { throw new ArgumentNullException(nameof(messageEvents)); } this.MessageEvents = messageEvents; if (links == null) { throw new ArgumentNullException(nameof(links)); } this.Links = links; this.ChildSpanCount = childSpanCount; this.Status = status; this.EndTimestamp = endTimestamp; }
public ISpanBuilder AddReference(string referenceType, ISpanContext referencedContext) { if (referencedContext is null) { return(this); } _references.Add(new Reference(referencedContext, referenceType)); return(this); }
/// <summary> /// Initializes a new instance of the <see cref="SpanContext"/> class /// that is the child of the specified parent context. /// </summary> /// <param name="parent">The parent context.</param> /// <param name="traceContext">The trace context.</param> /// <param name="serviceName">The service name to propagate to child spans.</param> internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName) : this(parent?.TraceId, serviceName) { SpanId = SpanIdGenerator.CreateNew(); Parent = parent; TraceContext = traceContext; if (parent is SpanContext spanContext) { Origin = spanContext.Origin; } }
/// <inheritdoc /> public void Inject <TCarrier>( ISpanContext spanContext, IFormat <TCarrier> format, TCarrier carrier) { var propagator = registry.Get(format); if (propagator == null) { throw new ArgumentException("invalid format: " + format); } propagator.Inject((WavefrontSpanContext)spanContext, carrier); }
public void ParseMissingSampledAndMissingFlag() { IDictionary <string, string> headersNotSampled = new Dictionary <string, string> { { B3Format.X_B3_TRACE_ID, TRACE_ID_BASE16 }, { B3Format.X_B3_SPAN_ID, SPAN_ID_BASE16 } }; ISpanContext spanContext = SpanContext.Create(TRACE_ID, SPAN_ID, TraceOptions.DEFAULT); Assert.Equal(spanContext, b3Format.Extract(headersNotSampled, Getter)); }
private string GetTraceId(TracingOptions options, ISpanContext context) { var traceId = context.TraceId.ToLowerBase16(); if (traceId.Length > 16 && options.UseShortTraceIds) { traceId = traceId.Substring(traceId.Length - 16, 16); } return(traceId); }
/// <summary> /// Initializes a new instance of the <see cref="SpanContext"/> class /// that is the child of the specified parent context. /// </summary> /// <param name="parent">The parent context.</param> /// <param name="traceContext">The trace context.</param> /// <param name="serviceName">The service name to propagate to child spans.</param> /// <param name="spanId">The propagated span id.</param> internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName, ulong?spanId = null) : this(parent?.TraceId, serviceName) { SpanId = spanId ?? SpanIdGenerator.ThreadInstance.CreateNew(); Parent = parent; TraceContext = traceContext; if (parent is SpanContext spanContext) { Origin = spanContext.Origin; } }
/// <summary> /// Initializes a new instance of the <see cref="SpanContext"/> class /// that is the child of the specified parent context. /// </summary> /// <param name="parent">The parent context.</param> /// <param name="traceContext">The trace context.</param> /// <param name="serviceName">The service name to propagate to child spans.</param> internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName) : this(parent?.TraceId, serviceName) { SpanId = _random.Value.NextUInt63(); Parent = parent; TraceContext = traceContext; if (parent is SpanContext spanContext) { Origin = spanContext.Origin; } }
public ISpanBuilder AddReference(string referenceType, ISpanContext referencedContext) { if (referencedContext == null) { return(this); } references = references ?? new List <Reference>(); references.Add(new Reference(referenceType, referencedContext)); return(this); }
/// <summary> /// Initializes a new instance of the <see cref="SpanContext"/> class /// that is the child of the specified parent context. /// </summary> /// <param name="parent">The parent context.</param> /// <param name="traceContext">The trace context.</param> /// <param name="serviceName">The service name to propagate to child spans.</param> internal SpanContext(ISpanContext parent, ITraceContext traceContext, string serviceName) : this(parent?.TraceId, serviceName) { Parent = parent; TraceContext = traceContext; if (SpanId == 0) { SpanId = GenerateId(); } }
public Span(string operationName, ISpanContext spanContext, ISpanRecorder spanChannel) { SpanContext = spanContext ?? throw new ArgumentNullException(nameof(spanContext)); Baggage = spanContext.Baggage; Tags = new TagCollection(); OperationName = operationName; _spanChannel = spanChannel ?? throw new ArgumentNullException(nameof(spanChannel)); _state = 0; _startTimestamp = Stopwatch.GetTimestamp(); }
public InProcessSampledSpanStoreTest() { sampledSpanContext = SpanContext.Create(TraceId.GenerateRandomId(random), SpanId.GenerateRandomId(random), TraceOptions.Builder().SetIsSampled(true).Build(), Tracestate.Empty); notSampledSpanContext = SpanContext.Create(TraceId.GenerateRandomId(random), SpanId.GenerateRandomId(random), TraceOptions.Default, Tracestate.Empty); parentSpanId = SpanId.GenerateRandomId(random); startEndHandler = new TestStartEndHandler(sampleStore); sampleStore.RegisterSpanNamesForCollection(new List <string>() { REGISTERED_SPAN_NAME }); }
private SpanBuilder(string name, SpanBuilderOptions options, ISpanContext remoteParentSpanContext = null, ISpan parent = null) { if (name == null) { throw new ArgumentNullException(nameof(name)); } Name = name; Parent = parent; RemoteParentSpanContext = remoteParentSpanContext; Options = options; }
public void Inject <TCarrier>(ISpanContext spanContext, IFormat <TCarrier> format, TCarrier carrier) { if ((format == BuiltinFormats.TextMap || format == BuiltinFormats.HttpHeaders) && carrier is ITextMap textMap) { _propagator.Inject((SpanContext)spanContext, textMap); return; } throw new ZipkinFormatException( $"Unrecognized carrier format [{format}]. Only ITextMap is supported by this driver."); }
public void Inject <TCarrier>(ISpanContext spanContext, IFormat <TCarrier> format, TCarrier carrier) { var formatString = format.ToString(); if (_injectors.ContainsKey(formatString)) { _injectors[formatString].Inject(spanContext, carrier); return; } throw new ArgumentException($"{formatString} is not a supported injection format", nameof(format)); }
private void Process(Message message) { ISpanContext context = _tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(message)); using (IScope scope = _tracer.BuildSpan("receive") .WithTag(Tags.SpanKind.Key, Tags.SpanKindServer) .WithTag(Tags.Component.Key, "example-server") .AsChildOf(context) .StartActive(finishSpanOnDispose: true)) { } }
public ISpan StartManual() { LambdaTracer tracer = LambdaTracer.Instance as LambdaTracer; ISpan activeSpan = tracer.ActiveSpan; ISpanContext parentSpanContext = null; if (!_ignoreActiveSpan && _parent == null && activeSpan != null) { AddReference(References.ChildOf, activeSpan.Context); parentSpanContext = activeSpan.Context; } else if (_parent != null) { parentSpanContext = _parent; } LambdaSpan parentSpan = null; if (parentSpanContext is LambdaSpanContext) { parentSpan = ((LambdaSpanContext)parentSpanContext).GetSpan(); } var guid = GuidGenerator.GenerateNewRelicGuid(); LambdaSpan newSpan; if (parentSpan != null) { newSpan = new LambdaSpan(_operationName, DateTimeOffset.UtcNow, _tags, parentSpan, guid); } else { var rootSpan = new LambdaRootSpan(_operationName, DateTimeOffset.UtcNow, _tags, guid, new DataCollector(_logger, tracer.DebugMode), new TransactionState(), new PrioritySamplingState(), new DistributedTracingState()); if (parentSpanContext is LambdaPayloadContext payloadContext) { rootSpan.ApplyLambdaPayloadContext(payloadContext); } else { rootSpan.ApplyAdaptiveSampling(tracer.AdaptiveSampler); } newSpan = rootSpan; } LambdaSpanContext spanContext = new LambdaSpanContext(newSpan); newSpan.SetContext(spanContext); return(newSpan); }
private static ISpanBuilder CreateSpan(ITracer tracer, string operationName, ISpanContext parentSpanCtx) { ISpanBuilder spanBuilder; spanBuilder = tracer.BuildSpan(operationName); if (parentSpanCtx != null) { spanBuilder = spanBuilder.AsChildOf(parentSpanCtx); } return(spanBuilder); }
public Task InjectAsync(ISpanContext spanContext, ICarrierWriter carrierWriter, ICarrier carrier) { if (carrierWriter == null) { throw new ArgumentNullException(nameof(carrierWriter)); } if (spanContext == null) { throw new ArgumentNullException(nameof(spanContext)); } return(carrierWriter.WriteAsync(spanContext.Package(), carrier)); }
public void Inject(ISpanContext spanContext, ICarrierWriter carrierWriter, ICarrier carrier) { if (carrierWriter == null) { throw new ArgumentNullException(nameof(carrierWriter)); } if (spanContext == null) { throw new ArgumentNullException(nameof(spanContext)); } carrierWriter.Write(spanContext.Package(), carrier); }
/// <summary> /// Creates a new <see cref="Span"/> with the specified parameters. /// </summary> /// <param name="operationName">The span's operation name</param> /// <param name="parent">The span's parent</param> /// <param name="serviceName">The span's service name</param> /// <param name="startTime">An explicit start time for that span</param> /// <param name="ignoreActiveScope">If set the span will not be a child of the currently active span</param> /// <returns>The newly created span</returns> public Span StartSpan(string operationName, ISpanContext parent = null, string serviceName = null, DateTimeOffset?startTime = null, bool ignoreActiveScope = false) { if (parent == null && !ignoreActiveScope) { parent = _scopeManager.Active?.Span?.Context; } ITraceContext traceContext; // try to get the trace context (from local spans) or // sampling priority (from propagated spans), // otherwise start a new trace context if (parent is SpanContext parentSpanContext) { traceContext = parentSpanContext.TraceContext ?? new TraceContext(this) { SamplingPriority = parentSpanContext.SamplingPriority }; } else { traceContext = new TraceContext(this); } var finalServiceName = serviceName ?? parent?.ServiceName ?? DefaultServiceName; var spanContext = new SpanContext(parent, traceContext, finalServiceName); var span = new Span(spanContext, startTime) { OperationName = operationName, }; var env = Settings.Environment; // automatically add the "env" tag if defined if (!string.IsNullOrWhiteSpace(env)) { span.SetTag(Tags.Env, env); } // Apply any global tags if (Settings.GlobalTags.Count > 0) { foreach (var entry in Settings.GlobalTags) { span.SetTag(entry.Key, entry.Value); } } traceContext.AddSpan(span); return(span); }
public void ShouldFallbackWhenInjectingWithFaultyCodec() { Tracer tracer = new Tracer.Builder("TracerResiliencyTestService") .WithReporter(new InMemoryReporter()) .WithSampler(new ConstSampler(true)) .RegisterCodec(BuiltinFormats.TextMap, new FaultyCodec()) .Build(); ISpanContext context = tracer.BuildSpan("test-span").Start().Context; tracer.Inject(context, BuiltinFormats.TextMap, new NoopTextMap()); }
public void ShouldFallbackWhenExtractingWithFaultyCodec() { Tracer tracer = new Tracer.Builder("TracerResiliencyTestService") .WithReporter(new InMemoryReporter()) .WithSampler(new ConstSampler(true)) .RegisterCodec(BuiltinFormats.TextMap, new FaultyCodec()) .Build(); ISpanContext spanContext = tracer.Extract(BuiltinFormats.TextMap, new NoopTextMap()); Assert.Null(spanContext); }
internal ZipkinSpan GenerateSpan(ISpanData spanData, ZipkinEndpoint localEndpoint) { ISpanContext context = spanData.Context; long startTimestamp = ToEpochMicros(spanData.StartTimestamp); long endTimestamp = ToEpochMicros(spanData.EndTimestamp); ZipkinSpan.Builder spanBuilder = ZipkinSpan.NewBuilder() .TraceId(EncodeTraceId(context.TraceId)) .Id(EncodeSpanId(context.SpanId)) .Kind(ToSpanKind(spanData)) .Name(spanData.Name) .Timestamp(ToEpochMicros(spanData.StartTimestamp)) .Duration(endTimestamp - startTimestamp) .LocalEndpoint(localEndpoint); if (spanData.ParentSpanId != null && spanData.ParentSpanId.IsValid) { spanBuilder.ParentId(EncodeSpanId(spanData.ParentSpanId)); } foreach (var label in spanData.Attributes.AttributeMap) { spanBuilder.PutTag(label.Key, AttributeValueToString(label.Value)); } Status status = spanData.Status; if (status != null) { spanBuilder.PutTag(STATUS_CODE, status.CanonicalCode.ToString()); if (status.Description != null) { spanBuilder.PutTag(STATUS_DESCRIPTION, status.Description); } } foreach (var annotation in spanData.Annotations.Events) { spanBuilder.AddAnnotation( ToEpochMicros(annotation.Timestamp), annotation.Event.Description); } foreach (var networkEvent in spanData.MessageEvents.Events) { spanBuilder.AddAnnotation( ToEpochMicros(networkEvent.Timestamp), networkEvent.Event.Type.ToString()); } return(spanBuilder.Build()); }
private ISpanContext TryExtractSpanContext(HttpRequest request) { try { ISpanContext spanContext = Tracer.Extract(BuiltinFormats.HttpHeaders, new HeaderDictionaryCarrier(request.Headers)); return(spanContext); } catch (Exception ex) { Logger.LogError(0, ex, "Extracting SpanContext failed"); return(null); } }
public ISpanBuilder AddReference(string referenceType, ISpanContext referencedContext) { if (!referencedContext.IsAppInsightsSpan()) { return(this); // stop execution here } if (_references == null) { _references = new List <SpanReference>(); } _references.Add(new SpanReference(referenceType, referencedContext)); return(this); }
public ISpanBuilder AddReference(string referenceType, ISpanContext referencedContext) { if (referencedContext is SpanContext context) { if (!string.Equals(References.ChildOf, referenceType) && !string.Equals(References.FollowsFrom, referenceType)) { return(this); } references.Add(new Reference(context, referenceType)); } return(this); }
protected SpanBase(ISpanContext context, SpanOptions options = SpanOptions.NONE) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.TraceOptions.IsSampled && !options.HasFlag(SpanOptions.RECORD_EVENTS)) { throw new ArgumentOutOfRangeException("Span is sampled, but does not have RECORD_EVENTS set."); } Context = context; Options = options; }