public void TryDecodeAndDeserializeDistributedTracePayload_ThrowsException_IfInvalidVersion()
{
var payload = BuildSampleDistributedTracePayload();
payload.Version = new int[] { 9999, 1 };
var encodedString = DistributedTracePayload.SerializeAndEncodeDistributedTracePayload(payload);
Assert.Throws <DistributedTraceAcceptPayloadVersionException>(() => DistributedTracePayload.TryDecodeAndDeserializeDistributedTracePayload(encodedString));
}
public void TestDistributedTraceInstrinsicsShowUpIn_ErrorEvents_ErrorTraces_SpanEvent_AnalyticEvent()
{
var dtPayload = new DistributedTracePayload
{
Type = "App",
AccountId = "test-accountid",
AppId = "test-appid",
Guid = "test-guid",
TraceId = "test-traceid",
TrustKey = "test-trustkey",
Priority = 1.0F,
Sampled = true,
Timestamp = DateTime.Now,
TransactionId = "test-transactionid",
};
var tags = new Dictionary <string, string>
{
{ "newrelic", dtPayload.SerializeAndEncodeDistributedTracePayload() }
};
var tracer = LambdaTracer.Instance;
var lambdaPayloadContext = (LambdaPayloadContext)tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(tags));
var startTime = DateTimeOffset.UtcNow;
var span = TestUtil.CreateRootSpan("operationName", startTime, new Dictionary <string, object>(), "testGuid", logger: _logger);
span.RootSpan.DistributedTracingState.SetInboundDistributedTracePayload(lambdaPayloadContext.GetPayload());
span.RootSpan.DistributedTracingState.SetTransportDurationInMillis(1000);
span.RootSpan.PrioritySamplingState.Priority = (span.RootSpan.DistributedTracingState.InboundPayload.Priority.HasValue)
? span.RootSpan.DistributedTracingState.InboundPayload.Priority.Value
: LambdaTracer.TracePriorityManager.Create();
span.RootSpan.PrioritySamplingState.Sampled = span.RootSpan.DistributedTracingState.InboundPayload.Sampled.Value;
var exception = new CustomException("my exception.", "this is a stack trace.");
var errorAttributes = CreateSpanErrorAttributes(exception, exception.Message, exception.StackTrace);
span.Log(errorAttributes);
span.Finish();
var deserializedPayload = JsonConvert.DeserializeObject <object[]>(_logger.LastLogMessage);
var data = TestUtil.DecodeAndDecompressNewRelicPayload(deserializedPayload[3] as string);
Assert.IsTrue(data.Contains("analytic_event_data"));
Assert.IsTrue(data.Contains("\"error\":true"));
Assert.IsTrue(data.Contains("\"error_event_data\":["));
Assert.IsTrue(data.Contains("\"error_data\":[null,[["));
Assert.AreEqual(4, TestUtil.CountStringOccurrences(data, "\"parent.type\":\"App\""));
Assert.AreEqual(4, TestUtil.CountStringOccurrences(data, "\"parent.account\":\"test-accountid\""));
Assert.AreEqual(4, TestUtil.CountStringOccurrences(data, "\"parent.app\":\"test-appid\""));
Assert.AreEqual(4, TestUtil.CountStringOccurrences(data, "\"parent.transportType\":\"Unknown\""));
Assert.AreEqual(4, TestUtil.CountStringOccurrences(data, "\"parent.transportDuration\":1000.0"));
}
public void SerializeAndEncodeDistributedTracePayload_CreatesCorrectEncodedString()
{
var payload = BuildSampleDistributedTracePayload();
var jsonString = payload.ToJson();
var encodedJsonString = Strings.Base64Encode(jsonString);
var serializedPayload = DistributedTracePayload.SerializeAndEncodeDistributedTracePayload(payload);
Assert.AreEqual(encodedJsonString, serializedPayload);
}
public void AcceptDistributedTraceHeadersHydratesValidNewRelicPayload()
{
var encodedPayload = DistributedTracePayload.SerializeAndEncodeDistributedTracePayload(BuildSampleDistributedTracePayload());
var headers = new Dictionary <string, string>()
{
{ NewRelicPayloadHeaderName, encodedPayload }
};
var tracingState = TracingState.AcceptDistributedTraceHeaders(carrier: headers, getter: GetHeader, transportType: TransportType.AMQP, agentTrustKey: TrustKey, transactionStartTime: DateTime.UtcNow.Add(TimeSpan.FromMilliseconds(1)));
Assert.IsNotNull(tracingState);
Assert.AreEqual(Type, tracingState.Type);
Assert.AreEqual(AccountId, tracingState.AccountId);
Assert.AreEqual(AppId, tracingState.AppId);
Assert.AreEqual(Guid, tracingState.Guid);
Assert.AreEqual(TraceId, tracingState.TraceId);
Assert.AreEqual(Priority, tracingState.Priority);
Assert.AreEqual(Sampled, tracingState.Sampled);
Assert.AreEqual(TransactionId, tracingState.TransactionId);
Assert.IsTrue(tracingState.Timestamp != default, $"Timestamp should not be {(DateTime)default}");
public void OneTimeSetUp()
{
// type, accountId, appId, guid, traceId, trustKey, priority, sampled, timestamp, transactionId
_dtPayload = new DistributedTracePayload
{
Type = "App",
AccountId = "test-accountid",
AppId = "test-appid",
Guid = "test-guid",
TraceId = "test-traceid",
TrustKey = "test-trustkey",
Priority = 1.0F,
Sampled = true,
Timestamp = DateTime.Now,
TransactionId = "test-transactionid"
};
_tags = new Dictionary <string, string>
{
{ "newrelic", _dtPayload.SerializeAndEncodeDistributedTracePayload() }
};
}
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 Extract_ReturnsLambdaPayloadContext_FromPayload()
{
var tracer = LambdaTracer.Instance;
var contextTextMap = tracer.Extract(BuiltinFormats.TextMap, new TextMapExtractAdapter(_tags));
var contextHttpHeaders = tracer.Extract(BuiltinFormats.HttpHeaders, new TextMapExtractAdapter(_tags));
var payloadEncodedMap = tracer.Extract(NewRelicFormats.Payload, new PayloadExtractAdapter(_dtPayload.SerializeAndEncodeDistributedTracePayload()));
var payloadJsonMap = tracer.Extract(NewRelicFormats.Payload, new PayloadExtractAdapter(_dtPayload.ToJson()));
Assert.That(contextTextMap, Is.TypeOf <LambdaPayloadContext>());
Assert.That(contextHttpHeaders, Is.TypeOf <LambdaPayloadContext>());
Assert.That(payloadEncodedMap, Is.TypeOf <LambdaPayloadContext>());
Assert.That(payloadJsonMap, Is.TypeOf <LambdaPayloadContext>());
}