public TraceEventDetails(TraceEventCache eventCache, string source, TraceEventType eventType, TraceId id, string format, params object[] args)
{
EventCache = eventCache;
Source = source;
EventType = eventType;
Id = id;
Format = format;
Args = args;
}
public SamplersTest()
{
traceId = TraceId.GenerateRandomId(random);
parentSpanId = SpanId.GenerateRandomId(random);
spanId = SpanId.GenerateRandomId(random);
sampledSpanContext = SpanContext.Create(traceId, parentSpanId, TraceOptions.Builder().SetIsSampled(true).Build());
notSampledSpanContext = SpanContext.Create(traceId, parentSpanId, TraceOptions.DEFAULT);
sampledSpan = new NoopSpan(sampledSpanContext, SpanOptions.RECORD_EVENTS);
}
public Property ShouldParse64BitTraceIds(long traceIdLow)
{
var traceId1 = new TraceId(traceIdLow);
var parsed = TraceId.TryParse(traceId1.ToString(), out var traceId2);
return parsed.Label($"Should have been able to parse {traceId1}")
.And(traceId2.Equals(traceId1)
.Label("Expected a trace parsed from an original trace to be equal to the original"));
}
public void CreateRandom64Bit_CreatesValid64BitId()
{
var traceId = TraceId.CreateRandomDataDogCompatible();
using (new AssertionScope())
{
FluentActions.Invoking(() => Convert.ToUInt64(traceId.ToString(), fromBase: 10)).Should().NotThrow();
}
}
public TraceEventDetails(TraceEventCache eventCache, string source, TraceEventType eventType, TraceId id, string format, params object[] args)
{
EventCache = eventCache;
Source = source;
EventType = eventType;
Id = id;
Format = format;
Args = args;
}
public SamplersTest()
{
traceId = TraceId.GenerateRandomId(random);
parentSpanId = SpanId.GenerateRandomId(random);
spanId = SpanId.GenerateRandomId(random);
sampledSpanContext = SpanContext.Create(traceId, parentSpanId, TraceOptions.Builder().SetIsSampled(true).Build(), Tracestate.Empty);
notSampledSpanContext = SpanContext.Create(traceId, parentSpanId, TraceOptions.Default, Tracestate.Empty);
sampledLink = Link.FromSpanContext(sampledSpanContext);
}
/// <summary>
/// Processes HTTP request.
/// </summary>
private void ProcessHTTPRequest(HttpContext context)
{
HttpRequest request = context.Request;
string headerString = null;
if (request.Headers.TryGetValue(TraceHeader.HeaderKey, out StringValues headerValue))
{
if (headerValue.ToArray().Length >= 1)
{
headerString = headerValue.ToArray()[0];
}
}
// Trace header doesn't exist, which means this is the root node. Create a new traceId and inject the trace header.
if (!TraceHeader.TryParse(headerString, out TraceHeader traceHeader))
{
_logger.DebugFormat("Trace header doesn't exist or not valid : ({0}). Injecting a new one.", headerString);
traceHeader = new TraceHeader
{
RootTraceId = TraceId.NewId(),
ParentId = null,
Sampled = SampleDecision.Unknown
};
}
bool isSampleDecisionRequested = traceHeader.Sampled == SampleDecision.Requested;
// Make sample decision
if (traceHeader.Sampled == SampleDecision.Unknown || traceHeader.Sampled == SampleDecision.Requested)
{
string serviceName = request.Host.Host;
string url = request.Path;
string method = request.Method;
traceHeader.Sampled = _recorder.SamplingStrategy.Sample(serviceName, url, method);
}
if (AWSXRayRecorder.Instance.IsLambda())
{
_recorder.BeginSubsegment(SegmentNamingStrategy.GetSegmentName(request));
}
else
{
_recorder.BeginSegment(SegmentNamingStrategy.GetSegmentName(request), traceHeader.RootTraceId, traceHeader.ParentId, traceHeader.Sampled);
}
if (!AWSXRayRecorder.Instance.IsTracingDisabled())
{
var requestAttributes = new Dictionary <string, object>();
PopulateRequestAttributes(request, requestAttributes);
_recorder.AddHttpInformation("request", requestAttributes);
}
if (isSampleDecisionRequested)
{
context.Response.Headers.Add(TraceHeader.HeaderKey, traceHeader.ToString()); // Its recommended not to modify response header after _next.Invoke() call
}
}
public Property Identical64BitTraceIdsShouldBeEqual(long traceIdLow)
{
var traceId1 = new TraceId(traceIdLow);
var traceId2 = new TraceId(traceIdLow);
return traceId1.Equals(traceId2).ToProperty()
.And(traceId1 == traceId2)
.And(!(traceId1 != traceId2));
}
public void SpanContext_ToString()
{
Assert.Contains(TraceId.FromBytes(firstTraceIdBytes).ToString(), first.ToString());
Assert.Contains(SpanId.FromBytes(firstSpanIdBytes).ToString(), first.ToString());
Assert.Contains(TraceOptions.DEFAULT.ToString(), first.ToString());
Assert.Contains(TraceId.FromBytes(secondTraceIdBytes).ToString(), second.ToString());
Assert.Contains(SpanId.FromBytes(secondSpanIdBytes).ToString(), second.ToString());
Assert.Contains(TraceOptions.Builder().SetIsSampled(true).Build().ToString(), second.ToString());
}
public override int GetHashCode()
{
unchecked
{
var hashCode = TraceId.GetHashCode();
hashCode = (hashCode * 397) ^ SpanId.GetHashCode();
return(hashCode);
}
}
public void GenerateSpan()
{
ZipkinEndpoint localEndpoint = new ZipkinEndpoint()
{
ServiceName = "tweetiebird"
};
var traceId = "d239036e7d5cec116b562147388b35bf";
var spanId = "9cc1e3049173be09";
var parentId = "8b03ab423da481c5";
Dictionary <string, IAttributeValue> attributes = new Dictionary <string, IAttributeValue>();
IList <ITimedEvent <IAnnotation> > annotations = new List <ITimedEvent <IAnnotation> >();
List <ITimedEvent <IMessageEvent> > networkEvents = new List <ITimedEvent <IMessageEvent> >()
{
TimedEvent <IMessageEvent> .Create(Timestamp.Create(EPOCH_SECONDS + 1505855799, 433901068), new MessageEventBuilder(MessageEventType.RECEIVED, 0, 0, 0).SetCompressedMessageSize(7).Build()),
TimedEvent <IMessageEvent> .Create(Timestamp.Create(EPOCH_SECONDS + 1505855799, 459486280), new MessageEventBuilder(MessageEventType.SENT, 0, 0, 0).SetCompressedMessageSize(13).Build())
};
ISpanData data = SpanData.Create(
SpanContext.Create(
TraceId.FromBytes(Arrays.StringToByteArray(traceId)),
SpanId.FromBytes(Arrays.StringToByteArray(spanId)),
TraceOptions.FromBytes(new byte[] { 1 })),
SpanId.FromBytes(Arrays.StringToByteArray(parentId)),
true, /* hasRemoteParent */
"Recv.helloworld.Greeter.SayHello", /* name */
Timestamp.Create(EPOCH_SECONDS + 1505855794, 194009601) /* startTimestamp */,
Attributes.Create(attributes, 0 /* droppedAttributesCount */),
TimedEvents <IAnnotation> .Create(annotations, 0 /* droppedEventsCount */),
TimedEvents <IMessageEvent> .Create(networkEvents, 0 /* droppedEventsCount */),
LinkList.Create(new List <ILink>(), 0 /* droppedLinksCount */),
null, /* childSpanCount */
Status.OK,
Timestamp.Create(EPOCH_SECONDS + 1505855799, 465726528) /* endTimestamp */);
var handler = new TraceExporterHandler(new TraceExporterOptions());
var result = handler.GenerateSpan(data, localEndpoint);
var zspan = ZipkinSpan.NewBuilder()
.TraceId(traceId)
.ParentId(parentId)
.Id(spanId)
.Kind(ZipkinSpanKind.SERVER)
.Name(data.Name)
.Timestamp(1505855794000000L + (194009601L / 1000))
.Duration(
(1505855799000000L + (465726528L / 1000))
- (1505855794000000L + (194009601L / 1000)))
.LocalEndpoint(localEndpoint)
.AddAnnotation(1505855799000000L + (433901068L / 1000), "RECEIVED")
.AddAnnotation(1505855799000000L + (459486280L / 1000), "SENT")
.PutTag("census.status_code", "OK")
.Build();
Assert.Equal(zspan, result);
}
public void ZipkinJSONTransport_ConvertSpan()
{
var span = Substitute.For <ILetsTraceSpan>();
var traceId = new TraceId {
High = 4, Low = 197376
};
var parentId = new SpanId(1);
var spanId = new SpanId(2);
var spanContext = new SpanContext(traceId, spanId, parentId);
var logs = new List <LogRecord> {
new LogRecord(DateTimeOffset.Now, new List <Field> {
new Field <string> {
Key = "field_log_key", Value = "message, yo"
}
})
};
var tags = new Dictionary <string, Field> {
{ Tags.SpanKind, new Field <string> {
Value = Tags.SpanKindServer
} },
{ "randomkey", new Field <bool> {
Value = false
} }
};
var operationName = "testing";
var startTime = DateTimeOffset.Parse("2/12/2018 5:49:19 PM +00:00");
var finishTime = DateTimeOffset.Parse("2/12/2018 5:49:37 PM +00:00");
var serviceName = "testingService";
var hostIpv4 = "192.168.1.1";
var tracer = Substitute.For <ILetsTraceTracer>();
span.Context.Returns(spanContext);
span.Tracer.Returns(tracer);
tracer.ServiceName.Returns(serviceName);
tracer.HostIPv4.Returns(hostIpv4);
span.Logs.Returns(logs);
span.Tags.Returns(tags);
span.OperationName.Returns(operationName);
span.StartTimestamp.Returns(startTime);
span.FinishTimestamp.Returns(finishTime);
var convertedSpan = ZipkinJSONTransport.ConvertSpan(span);
Assert.Equal(traceId.ToString(), convertedSpan.TraceId);
Assert.Equal(parentId.ToString(), convertedSpan.ParentId);
Assert.Equal(spanId.ToString(), convertedSpan.Id);
Assert.Equal(operationName, convertedSpan.Name);
Assert.Equal(1518457759000000, convertedSpan.Timestamp);
Assert.Equal(18000000, convertedSpan.Duration);
Assert.Equal(serviceName, convertedSpan.LocalEndpoint.ServiceName);
Assert.Equal(hostIpv4, convertedSpan.LocalEndpoint.Ipv4);
Assert.Equal("field_log_key: message, yo", convertedSpan.Annotations[0].Value);
Assert.Equal(false.ToString(), convertedSpan.Tags["randomkey"]);
Assert.Equal(1, convertedSpan.Tags.Count);
Assert.Equal("SERVER", convertedSpan.Kind.GetValueOrDefault().ToString());
}
public SamplersTest()
{
traceId = TraceId.GenerateRandomId(random);
parentSpanId = SpanId.GenerateRandomId(random);
spanId = SpanId.GenerateRandomId(random);
sampledSpanContext = SpanContext.Create(traceId, parentSpanId, TraceOptions.Builder().SetIsSampled(true).Build(), Tracestate.Empty);
notSampledSpanContext = SpanContext.Create(traceId, parentSpanId, TraceOptions.Default, Tracestate.Empty);
sampledSpan = new NoopSpan(sampledSpanContext, SpanOptions.RecordEvents);
}
public override ISpanContext Extract <C>(C carrier, IGetter <C> getter)
{
if (carrier == null)
{
throw new ArgumentNullException(nameof(carrier));
}
if (getter == null)
{
throw new ArgumentNullException(nameof(getter));
}
try
{
ITraceId traceId;
string traceIdStr = getter.Get(carrier, X_B3_TRACE_ID);
if (traceIdStr != null)
{
if (traceIdStr.Length == TraceId.SIZE)
{
// This is an 8-byte traceID.
traceIdStr = UPPER_TRACE_ID + traceIdStr;
}
traceId = TraceId.FromLowerBase16(traceIdStr);
}
else
{
throw new SpanContextParseException("Missing X_B3_TRACE_ID.");
}
ISpanId spanId;
string spanIdStr = getter.Get(carrier, X_B3_SPAN_ID);
if (spanIdStr != null)
{
spanId = SpanId.FromLowerBase16(spanIdStr);
}
else
{
throw new SpanContextParseException("Missing X_B3_SPAN_ID.");
}
TraceOptions traceOptions = TraceOptions.DEFAULT;
if (SAMPLED_VALUE.Equals(getter.Get(carrier, X_B3_SAMPLED)) ||
FLAGS_VALUE.Equals(getter.Get(carrier, X_B3_FLAGS)))
{
traceOptions = TraceOptions.Builder().SetIsSampled(true).Build();
}
return(SpanContext.Create(traceId, spanId, traceOptions));
}
catch (Exception e)
{
throw new SpanContextParseException("Invalid input.", e);
}
}
/// <inheritdoc/>
public SpanContext Extract <T>(T carrier, Func <T, string, IEnumerable <string> > getter)
{
if (carrier == null)
{
throw new ArgumentNullException(nameof(carrier));
}
if (getter == null)
{
throw new ArgumentNullException(nameof(getter));
}
try
{
TraceId traceId;
var traceIdStr = getter(carrier, XB3TraceId)?.FirstOrDefault();
if (traceIdStr != null)
{
if (traceIdStr.Length == TraceId.Size)
{
// This is an 8-byte traceID.
traceIdStr = UpperTraceId + traceIdStr;
}
traceId = TraceId.FromLowerBase16(traceIdStr);
}
else
{
throw new SpanContextParseException("Missing X_B3_TRACE_ID.");
}
SpanId spanId;
var spanIdStr = getter(carrier, XB3SpanId)?.FirstOrDefault();
if (spanIdStr != null)
{
spanId = SpanId.FromLowerBase16(spanIdStr);
}
else
{
throw new SpanContextParseException("Missing X_B3_SPAN_ID.");
}
var traceOptions = TraceOptions.Default;
if (SampledValue.Equals(getter(carrier, XB3Sampled)?.FirstOrDefault()) ||
FlagsValue.Equals(getter(carrier, XB3Flags)?.FirstOrDefault()))
{
traceOptions = TraceOptions.Builder().SetIsSampled(true).Build();
}
return(SpanContext.Create(traceId, spanId, traceOptions, Tracestate.Empty));
}
catch (Exception e)
{
throw new SpanContextParseException("Invalid input.", e);
}
}
/// <summary>
/// Write a trace event with a message and exception details to the underlying trace source and issue a
/// Debug.Fail() call if the condition is false.
/// </summary>
/// <remarks>
/// Note: often the fact that an exception has been thrown by itself is enough to determine that the message
/// should be logged. If so please use DebugTraceException() instead. This method is for if the exception should
/// only be logged if some additional condition is also false.
/// </remarks>
/// <param name="condition">Must be false for Debug or Trace event to be issued.</param>
/// <param name="eventType">Event type that specifies the verbosity level of the trace.</param>
/// <param name="traceId">The category of the caller's product feature.</param>
/// <param name="exception">The exception to be logged.</param>
/// <param name="message">Message to be traced along with the event.</param>
/// <returns>True if event was successfully written or the condition was true</returns>
public bool AssertTraceException2(bool condition, TraceEventType eventType, TraceId traceId, Exception exception, string message,
[CallerLineNumber] int lineNumber = 0, [CallerFilePath] string fileName = "",
[CallerMemberName] string memberName = "")
{
if (!condition)
{
return(DebugTraceException2(eventType, (int)traceId, exception, message, lineNumber, fileName, memberName));
}
return(true);
}
private static void ReadMessage(ConsoleCommand command)
{
string messageId = command.Current;
ConsoleWriter.WriteInGreen($"Reading message {messageId}..");
Message message = _messageProvider.GetMessage(TraceId.New(), messageId);
ConsoleWriter.WriteInGreen(message.Body);
}
public RssFeedsController(TraceId traceId,
ILogger <RssFeedsController> logger,
IRssFeedsService rssFeedsService,
IRssFeedsHttpService rssFeedsHttpService)
{
_traceId = traceId;
_logger = logger;
_rssFeedsService = rssFeedsService;
_rssFeedsHttpService = rssFeedsHttpService;
}
private static Span GetMyServiceSpan()
{
var span = new Span(new SpanContext(TraceId.CreateFromUlong(_id++), _id++, null, serviceName: ServiceName), DateTimeOffset.Now)
{
OperationName = OperationName
};
span.SetTag(Tags.Environment, Env);
return(span);
}
public RssFeedsService(TraceId traceId,
ILogger <RssFeedsService> logger,
IRssFeedsRepository repository,
IEventBus eventBus)
{
_traceId = traceId;
_logger = logger;
_repository = repository;
_eventBus = eventBus;
}
private static Span GetMyServiceSpan(TraceId traceId)
{
var span = new Span(new SpanContext(traceId, spanId: 1, null, serviceName: ServiceName), DateTimeOffset.Now)
{
OperationName = OperationName
};
span.SetTag(Tags.Env, Env);
return(span);
}
public SpanContext Extract(IPropagatorMap propagatorMap)
{
if (propagatorMap == null)
{
throw new ArgumentNullException(nameof(propagatorMap));
}
TraceId?traceId = null;
ulong? spanId = null, parentId = null;
bool sampled = false, debug = false;;
foreach (var entry in propagatorMap)
{
if (string.Equals(entry.Key, TraceIdHeader, StringComparison.OrdinalIgnoreCase))
{
if (TraceId.TryParse(entry.Value, out var _trace))
{
traceId = _trace;
}
}
else if (string.Equals(entry.Key, SpanIdHeader, StringComparison.OrdinalIgnoreCase))
{
if (ulong.TryParse(entry.Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var _spanId))
{
spanId = _spanId;
}
}
else if (string.Equals(entry.Key, ParentIdHeader, StringComparison.OrdinalIgnoreCase))
{
if (ulong.TryParse(entry.Value, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var _parent))
{
parentId = _parent;
}
}
else if (string.Equals(entry.Key, SampledHeader, StringComparison.OrdinalIgnoreCase))
{
sampled = string.Equals(entry.Value, SampledTrue);
}
else if (string.Equals(entry.Key, DebugHeader, StringComparison.OrdinalIgnoreCase))
{
debug = string.Equals(entry.Value, SampledTrue);
}
}
if (traceId == null || spanId == null)
{
return(null);
}
return(new SpanContext(traceId.Value,
spanId.Value,
parentId,
sampled,
debug,
shared: false));
}
public override int GetHashCode()
{
unchecked
{
var hashCode = TraceId != null?TraceId.GetHashCode() : 0;
hashCode = (hashCode * 397) ^ (SpanId != null ? SpanId.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (ParentId != null ? ParentId.GetHashCode() : 0);
return(hashCode);
}
}
public void CreateRandom_CreatesValid128BitId()
{
var traceId = TraceId.CreateRandom();
using (new AssertionScope())
{
traceId.ToString().Should().HaveLength(32);
FluentActions.Invoking(() => Convert.ToUInt64(traceId.ToString().Substring(startIndex: 0, length: 16), fromBase: 16)).Should().NotThrow();
FluentActions.Invoking(() => Convert.ToUInt64(traceId.ToString().Substring(startIndex: 16, length: 16), fromBase: 16)).Should().NotThrow();
}
}
public SamplingStatus Sample(string operationName, TraceId traceId)
{
var sample1 = sampler1.Sample(operationName, traceId);
if (sample1)
{
var sample2 = sampler2.Sample(operationName, traceId);
return(sample2);
}
return(sample1);
}
public CloseReopenTransactionBuilder()
{
var now = TimeProvider.Now;
_description = new CustomerFriendlyDescription($"{nameof(CloseReopenTransactionBuilder).Replace("Builder", "")}");
_transactionDateTime = new TransactionDateTime(now);
_businessDate = new BusinessDate(now);
_cardPresent = new CardPresent(false);
_currency = new Currency(Currency.Kind.DKK);
_traceId = new TraceId(Guid.NewGuid());
}
public override int GetHashCode()
{
int hashcode = 157;
unchecked {
hashcode = (hashcode * 397) + TraceId.GetHashCode();
hashcode = (hashcode * 397) + Sampled.GetHashCode();
hashcode = (hashcode * 397) + Baggage.GetHashCode();
}
return(hashcode);
}
private string EncodeTraceId(TraceId traceId)
{
var id = traceId.ToLowerBase16();
if (id.Length > 16 && this.options.UseShortTraceIds)
{
id = id.Substring(id.Length - 16, 16);
}
return(id);
}
internal void Inject_DoNotCreateCorrectTraceStateHeaderIfNotPresent(IHeadersCollection headers)
{
var traceId = TraceId.CreateFromString("0af7651916cd43dd8448eb211c80319c");
const ulong spanId = 67667974448284343;
var spanContext = new SpanContext(traceId, spanId, traceState: null);
var propagator = new W3CSpanContextPropagator(new OtelTraceIdConvention());
propagator.Inject(spanContext, headers);
headers.GetValues(W3CHeaderNames.TraceState).Should().HaveCount(0);
}
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
});
}
/// <summary>Makes a decision on tracing a span.</summary>
/// <param name="operation">The operation being executed. (This is not just the HTTP Method)</param>
/// <param name="id">The ID of the span.</param>
public SamplingStatus Sample(string operation, TraceId id)
{
lock (_lock)
{
var context = HttpContextAccessor.HttpContext;
return(SamplingFilters.Find(f => f.ShouldSample(context.Request))
?.TargetSampler?.Sample(operation, id)
?? DefaultSampler.Sample(operation, id));
}
}
