public void TryBuildOutgoingPayload_ReturnsNull_WhenDoesNotContainGuidOrTransactionId(string guid, string transactionId)
{
var payload = DistributedTracePayload.TryBuildOutgoingPayload(TransportType, AccountId, AppId, guid, TraceId,
TrustKey, Priority, Sampled, Timestamp, transactionId);
Assert.Null(payload);
}
public void DistributedTracePayload_RoundTrip(
[Values("App", "Mobile")] string type,
[Values("12345")] string accountId,
[Values("1111")] string appId,
[Random(0ul, 0xfffffffffffffffful, 1), Values(ulong.MinValue, ulong.MaxValue)] ulong parentId,
[Random(0ul, 0xfffffffffffffffful, 1), Values(ulong.MinValue, ulong.MaxValue)] ulong guid,
[Random(0ul, 0xfffffffffffffffful, 1), Values(ulong.MinValue, ulong.MaxValue)] ulong traceId,
[Values("56789")] string trustKey,
[Random(0f, 1.0f, 1), Values(0.0f, 1.0f, 0.1234567f)] float priority,
[Values(true, false)] bool sampled,
[Values(new[] { 1970, 1, 1, 0, 0, 1 }, new[] { 2018, 12, 31, 23, 59, 59 })] int[] time,
[Random(0ul, 0xfffffffffffffffful, 1), Values(ulong.MinValue, ulong.MaxValue)] ulong _transactionId)
{
var input = DistributedTracePayload.TryBuildOutgoingPayload(type, accountId, appId, $"{guid:X8}", $"{traceId:X8}", trustKey, priority, sampled,
new DateTime(time[0], time[1], time[2], time[3], time[4], time[5], DateTimeKind.Utc), $"{_transactionId:X8}");
var serialized = input.ToJson();
var deserialized = DistributedTracePayload.TryBuildIncomingPayloadFromJson(serialized);
Assert.That(deserialized.Version, Is.Not.Null);
Assert.That(deserialized.Version, Has.Exactly(2).Items);
Assert.That(deserialized.Version[0], Is.EqualTo(0));
Assert.That(deserialized.Version[1], Is.EqualTo(1));
Assert.That(deserialized.Type, Is.EqualTo(input.Type));
Assert.That(deserialized.AccountId, Is.EqualTo(input.AccountId));
Assert.That(deserialized.AppId, Is.EqualTo(input.AppId));
Assert.That(deserialized.Guid, Is.EqualTo(input.Guid));
Assert.That(deserialized.TraceId, Is.EqualTo(input.TraceId));
Assert.That(deserialized.TrustKey, Is.EqualTo(input.TrustKey));
Assert.That(deserialized.Sampled, Is.EqualTo(input.Sampled));
Assert.That(deserialized.Timestamp, Is.EqualTo(input.Timestamp));
Assert.That(deserialized.TransactionId, Is.EqualTo(input.TransactionId));
}
private static DistributedTracePayload BuildSampleDistributedTracePayload()
{
return(DistributedTracePayload.TryBuildOutgoingPayload(
Type.ToString(),
AccountId,
AppId,
Guid,
TraceId,
TrustKey,
Priority,
Sampled,
Timestamp,
TransactionId));
}
public void DistributedTracePayloadWithZeroBasedTimestampThrows()
{
var type = "App";
var accountId = "12345";
var appId = "1111";
var parentId = $"{0xfffffffffffffffful:X9}";
var guid = $"{0xfffffffffffffffful:X9}";
var traceId = $"{0xfffffffffffffffful:X9}";
var trustKey = "56789";
var priority = 0f;
var sampled = true;
var time = new int[] { 1970, 1, 1, 0, 0, 0 };
var timestamp = new DateTime(time[0], time[1], time[2], time[3], time[4], time[5], DateTimeKind.Utc);
var transactionId = $"{0xfffffffffffffffful:X9}";
var input = DistributedTracePayload.TryBuildOutgoingPayload(type, accountId, appId, $"{guid:X8}", $"{traceId:X8}", trustKey, priority, sampled, timestamp, transactionId);
var serialized = input.ToJson();
Assert.Throws <DistributedTraceAcceptPayloadParseException>(() => DistributedTracePayload.TryBuildIncomingPayloadFromJson(serialized));
}
public void Inject <TCarrier>(ISpanContext spanContext, IFormat <TCarrier> format, TCarrier carrier)
{
var context = (LambdaSpanContext)spanContext;
var span = context.GetSpan();
var payload = DistributedTracePayload.TryBuildOutgoingPayload(
type: "App",
accountId: AccountId,
appId: PrimaryApplicationId,
guid: span.Guid(),
traceId: span.RootSpan.DistributedTracingState.InboundPayload?.TraceId ?? span.RootSpan.TransactionState.TransactionId,
trustKey: TrustedAccountKey,
priority: span.RootSpan.PrioritySamplingState.Priority,
sampled: span.RootSpan.PrioritySamplingState.Sampled,
timestamp: span.TimeStamp.DateTime,
transactionId: span.RootSpan.TransactionState.TransactionId
);
// If we couldnt build a payload just return
if (payload == null)
{
return;
}
if (format.Equals(BuiltinFormats.TextMap))
{
// "text" version of payload
((ITextMap)carrier).Set(NEWRELIC_TRACE_HEADER, payload.ToJson());
}
else if (format.Equals(BuiltinFormats.HttpHeaders))
{
// "httpSafe" version of payload
((ITextMap)carrier).Set(NEWRELIC_TRACE_HEADER, payload.SerializeAndEncodeDistributedTracePayload());
}
//else if (format.Equals(BuiltinFormats.Binary))
//{
// var payloadBytes = Encoding.UTF8.GetBytes(payload.ToJson());
// ((MemoryStream)carrier).Write(payloadBytes, 0, payloadBytes.Length);
//}
}
private IDistributedTracePayload TryGetOutboundDistributedTraceApiModelInternal(IInternalTransaction transaction, ISegment segment, DateTime timestamp)
{
var accountId = _configurationService.Configuration.AccountId;
var appId = _configurationService.Configuration.PrimaryApplicationId;
if (!_configurationService.Configuration.SpanEventsEnabled && !_configurationService.Configuration.TransactionEventsEnabled)
{
Log.Finest("Did not generate payload because Span Events and Transaction Events were both disabled, preventing a traceable payload.");
return(DistributedTraceApiModel.EmptyModel);
}
transaction.SetSampled(_adaptiveSampler);
var transactionIsSampled = transaction.Sampled;
if (transactionIsSampled.HasValue == false)
{
Log.Error("Did not generate payload because transaction sampled value was null.");
return(DistributedTraceApiModel.EmptyModel);
}
var payloadGuid = _configurationService.Configuration.SpanEventsEnabled ? segment?.SpanId : null;
var trustKey = _configurationService.Configuration.TrustedAccountKey;
var transactionId = (_configurationService.Configuration.TransactionEventsEnabled) ? transaction.Guid : null;
var traceId = transaction.TraceId;
var distributedTracePayload = DistributedTracePayload.TryBuildOutgoingPayload(
DistributedTraceTypeDefault,
accountId,
appId,
payloadGuid,
traceId,
trustKey,
transaction.Priority,
transactionIsSampled,
timestamp,
transactionId);
if (distributedTracePayload == null)
{
return(DistributedTraceApiModel.EmptyModel);
}
string encodedPayload;
try
{
encodedPayload = DistributedTracePayload.SerializeAndEncodeDistributedTracePayload(distributedTracePayload);
}
catch (Exception ex)
{
Log.Error($"Failed to get encoded distributed trace headers for outbound request: {ex}");
_agentHealthReporter.ReportSupportabilityDistributedTraceCreatePayloadException();
return(DistributedTraceApiModel.EmptyModel);
}
transaction.TransactionMetadata.HasOutgoingTraceHeaders = true;
if (_configurationService.Configuration.PayloadSuccessMetricsEnabled)
{
_agentHealthReporter.ReportSupportabilityDistributedTraceCreatePayloadSuccess();
}
return(new DistributedTraceApiModel(encodedPayload));
}
public void BuildOutgoingPayload_ReturnsNull_WhenRequiredFieldsNotPresent(string type, string accountId, string appId, string traceId)
{
var payload = DistributedTracePayload.TryBuildOutgoingPayload(type, accountId, appId, Guid, traceId, TrustKey, Priority, Sampled, Timestamp, TransactionId);
Assert.Null(payload);
}