/// <summary>
/// Streams subsegments of instance of <see cref="Entity"/>.
/// </summary>
/// <param name="entity">Instance of <see cref="Entity"/>.</param>
/// <param name="emitter">Instance of <see cref="ISegmentEmitter"/>.</param>
public void Stream(Entity entity, ISegmentEmitter emitter)
{
lock (entity.Subsegments)
{
foreach (var next in entity.Subsegments)
{
Stream(next, emitter);
}
entity.Subsegments.RemoveAll(x => x.HasStreamed);
}
if (entity is Segment || entity.IsInProgress || entity.Reference > 0 || entity.IsSubsegmentsAdded)
{
return;
}
Subsegment subsegment = entity as Subsegment;
subsegment.TraceId = entity.RootSegment.TraceId;
subsegment.Type = "subsegment";
subsegment.ParentId = subsegment.Parent.Id;
emitter.Send(subsegment);
subsegment.RootSegment.DecrementSize();
subsegment.HasStreamed = true;
}
public void TestSubsegmentIsSerializable()
{
Subsegment subsegment = new Subsegment("test");
string testNamespace = "namespace";
subsegment.Namespace = testNamespace;
Entity parent = new Segment("parent", TraceId);
subsegment.Parent = parent;
subsegment.HasStreamed = true;
string type = "type1";
subsegment.Type = type;
string precursorId = Entity.GenerateId();
subsegment.AddPrecursorId(precursorId);
Subsegment subsegmentAfterSerialize = (Subsegment)SerializeAndDeserialize(subsegment);
Assert.AreEqual(testNamespace, subsegmentAfterSerialize.Namespace);
Assert.AreEqual(parent.TraceId, subsegmentAfterSerialize.Parent.TraceId);
Assert.IsTrue(subsegmentAfterSerialize.HasStreamed);
Assert.AreEqual(type, subsegmentAfterSerialize.Type);
Assert.AreEqual(precursorId, subsegmentAfterSerialize.PrecursorIds.First());
}
public void TestAddRefAndReleaseWithTwoSubsegment()
{
var s1 = new Segment("s1", TraceId);
var s21 = new Subsegment("s21");
var s22 = new Subsegment("s22");
s1.AddSubsegment(s21);
s1.AddSubsegment(s22);
Assert.AreEqual(s1.Reference, 3);
Assert.AreEqual(s21.Reference, 1);
Assert.AreEqual(s22.Reference, 1);
s21.Release();
Assert.AreEqual(s1.Reference, 2);
Assert.AreEqual(s21.Reference, 0);
Assert.AreEqual(s22.Reference, 1);
Assert.IsFalse(s1.IsEmittable());
Assert.IsFalse(s21.IsEmittable());
Assert.IsFalse(s22.IsEmittable());
s22.Release();
Assert.AreEqual(s1.Reference, 1);
Assert.AreEqual(s22.Reference, 0);
Assert.IsFalse(s1.IsEmittable());
Assert.IsFalse(s22.IsEmittable());
s1.Release();
Assert.AreEqual(s1.Reference, 0);
Assert.IsTrue(s1.IsEmittable());
Assert.IsTrue(s21.IsEmittable());
Assert.IsTrue(s22.IsEmittable());
}
public void TestAddRefAndReleaseWithThreeSegment()
{
var s1 = new Segment("s1", TraceId);
var s2 = new Subsegment("s2");
var s3 = new Subsegment("s3");
s1.AddSubsegment(s2);
s2.AddSubsegment(s3);
Assert.AreEqual(s1.Reference, 2);
Assert.AreEqual(s2.Reference, 2);
Assert.AreEqual(s3.Reference, 1);
s2.Release();
Assert.AreEqual(s1.Reference, 2);
Assert.AreEqual(s2.Reference, 1);
Assert.AreEqual(s3.Reference, 1);
Assert.IsFalse(s1.IsEmittable());
Assert.IsFalse(s2.IsEmittable());
Assert.IsFalse(s3.IsEmittable());
s3.Release();
Assert.AreEqual(s1.Reference, 1);
Assert.AreEqual(s2.Reference, 0);
Assert.AreEqual(s3.Reference, 0);
Assert.IsFalse(s1.IsEmittable());
Assert.IsFalse(s2.IsEmittable());
Assert.IsFalse(s3.IsEmittable());
s1.Release();
Assert.AreEqual(s1.Reference, 0);
Assert.IsTrue(s1.IsEmittable());
Assert.IsTrue(s2.IsEmittable());
Assert.IsTrue(s3.IsEmittable());
}
private void AssertExpectedSqlInformation(Subsegment subsegment)
{
Assert.IsNotNull(subsegment);
Assert.IsNotNull(subsegment.Sql);
Assert.AreEqual(_connectionString, subsegment.Sql["connection_string"]);
Assert.AreEqual(connection.ServerVersion, subsegment.Sql["database_version"]);
}
public void TestAsyncCreateTwoSubsegment()
{
_recorder.BeginSegment("parent", TraceId);
Segment parent = (Segment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
Subsegment child1 = null;
Subsegment child2 = null;
Task task1 = Task.Run(async() =>
{
_recorder.BeginSubsegment("child1");
await Task.Delay(1000); // Ensure task1 will not complete when task1 is running
child1 = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.EndSubsegment();
});
Task task2 = Task.Run(() =>
{
_recorder.BeginSubsegment("child2");
child2 = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.EndSubsegment();
});
Task.WaitAll(task1, task2);
_recorder.EndSegment();
Assert.IsNotNull(child1);
Assert.IsNotNull(child2);
Assert.ReferenceEquals(parent, child1.Parent);
Assert.ReferenceEquals(parent, child2.Parent);
Assert.IsTrue(parent.Subsegments.Contains(child1));
Assert.IsTrue(parent.Subsegments.Contains(child2));
}
public async Task TestAsyncCreateSubsegmentInAChain()
{
_recorder.BeginSegment("parent", TraceId);
var parent = AWSXRayRecorder.Instance.TraceContext.GetEntity();
Subsegment subsegment1 = null;
Subsegment subsegment2 = null;
await Task.Run(async() =>
{
_recorder.BeginSubsegment("subsegment1");
subsegment1 = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
await Task.Run(() =>
{
_recorder.BeginSubsegment("subsegment2");
subsegment2 = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.EndSubsegment();
});
_recorder.EndSubsegment();
});
_recorder.EndSegment();
Assert.ReferenceEquals(parent, subsegment1.Parent);
Assert.IsTrue(parent.Subsegments.Contains(subsegment1));
Assert.ReferenceEquals(subsegment1, subsegment2.Parent);
Assert.IsTrue(subsegment1.Subsegments.Contains(subsegment2));
}
public async Task TestSubsegmentOutLiveParent()
{
var mockEmitter = new Mock <ISegmentEmitter>();
using (var client = AWSXRayRecorderFactory.CreateAWSXRayRecorder(mockEmitter.Object))
{
client.BeginSegment("parent", TraceId);
var parent = AWSXRayRecorder.Instance.TraceContext.GetEntity();
Subsegment child = null;
Task task = Task.Run(async() =>
{
client.BeginSubsegment("child");
child = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
await Task.Delay(1000); // Wait for parent to end first
client.EndSubsegment();
});
await Task.Delay(50); // Wait to ensure subsegment has started
client.EndSegment();
// Subsegment is not ended
mockEmitter.Verify(x => x.Send(It.IsAny <Segment>()), Times.Never);
Task.WaitAll(task);
Assert.IsNotNull(child);
// subsegment ends
mockEmitter.Verify(x => x.Send(It.IsAny <Segment>()), Times.Once);
}
}
/// <summary>
/// Begin a tracing subsegment. A new segment will be created and added as a subsegment to previous segment.
/// </summary>
/// <param name="name">Name of the operation.</param>
/// <exception cref="ArgumentNullException">The argument has a null value.</exception>
/// <exception cref="EntityNotAvailableException">Entity is not available in trace context.</exception>
public override void BeginSubsegment(string name)
{
try
{
if (IsTracingDisabled())
{
_logger.DebugFormat("X-Ray tracing is disabled, do not start subsegment");
return;
}
// If the request is not sampled, a segment will still be available in TraceContext to
// stores the information of the trace. The trace information will still propagated to
// downstream service, in case downstream may overwrite the sample decision.
Entity parentEntity = TraceContext.GetEntity();
// If the segment is not sampled, do nothing and exit.
if (parentEntity.Sampled != SampleDecision.Sampled)
{
_logger.DebugFormat("Do not start subsegment because the segment doesn't get sampled. ({0})", name);
return;
}
Subsegment subsegment = new Subsegment(name);
parentEntity.AddSubsegment(subsegment);
subsegment.Sampled = parentEntity.Sampled;
subsegment.SetStartTimeToNow();
TraceContext.SetEntity(subsegment);
}
catch (EntityNotAvailableException e)
{
HandleEntityNotAvailableException(e, "Failed to start subsegment because the parent segment is not available.");
}
}
private void AssertTraceCollected(Subsegment subsegment)
{
Assert.AreEqual(connection.ConnectionString, subsegment.Sql["connection_string"]);
Assert.AreEqual(database, subsegment.Sql["database_type"]);
Assert.AreEqual(connection.ServerVersion, subsegment.Sql["database_version"]);
Assert.AreEqual(nameSpace, subsegment.Namespace);
Assert.IsTrue(subsegment.HasFault);
}
public void TestCreateSubsegmentWithName()
{
var subsegment = new Subsegment("test");
Assert.AreEqual(subsegment.Name, "test");
Assert.IsTrue(Entity.IsIdValid(subsegment.Id));
Assert.IsNull(subsegment.TraceId);
Assert.IsNull(subsegment.ParentId);
Assert.IsFalse(subsegment.IsSubsegmentsAdded);
}
public void TestAddSegment()
{
var parent = new Segment("parent", TraceId);
var child = new Subsegment("child");
parent.AddSubsegment(child);
Assert.ReferenceEquals(child.Parent, parent);
Assert.IsTrue(parent.Subsegments.Contains(child));
}
public void TestSubsegment()
{
_recorder.BeginSubsegment("subsegment1");
Subsegment subsegment1 = (Subsegment)TraceContext.GetEntity();
FacadeSegment facadeSegment = (FacadeSegment)subsegment1.RootSegment;
_recorder.EndSubsegment();
Assert.AreEqual(facadeSegment.GetType(), typeof(FacadeSegment));
Assert.IsFalse(facadeSegment.Subsegments.Contains(subsegment1)); //only subsegment is streamed
Assert.IsFalse(TraceContext.IsEntityPresent()); // facade segment is cleared from TraceContext
}
public void TestMarshallNamespace()
{
var subsegment = new Subsegment("test");
subsegment.Id = "1111111111111111";
subsegment.Namespace = "remote";
var actual = _marshaller.Marshall(subsegment);
var expected = "{\"format\":\"json\",\"version\":1}\n{\"id\":\"1111111111111111\",\"start_time\":0,\"end_time\":0,\"name\":\"test\",\"namespace\":\"remote\"}";
Assert.AreEqual(expected, actual);
}
public void TestMarshallThrottle()
{
var subsegment = new Subsegment("test");
subsegment.Id = "1111111111111111";
subsegment.IsThrottled = true;
var actual = _marshaller.Marshall(subsegment);
var expected = "{\"format\":\"json\",\"version\":1}\n{\"id\":\"1111111111111111\",\"start_time\":0,\"end_time\":0,\"name\":\"test\",\"throttle\":true}";
Assert.AreEqual(expected, actual);
}
public void TestLambdaVariablesNotSetCorrectly()
{
String invalidTraceHeader = "Root=" + TraceId + ";Parent=53995c3f42cd8ad8"; //sample decision is missing
Environment.SetEnvironmentVariable(AWSXRayRecorder.LambdaTraceHeaderKey, invalidTraceHeader);
_recorder.BeginSubsegment("subsegment1");
Subsegment subsegment = (Subsegment)TraceContext.GetEntity(); //subsegment added with sample decision set to not sampled
Assert.AreEqual(SampleDecision.NotSampled, subsegment.Sampled);
_recorder.EndSubsegment(); //subsegment not sampled since invalid TraceHeader value set in the lambda environment
Assert.IsFalse(TraceContext.IsEntityPresent()); // Facade segment not present in the callcontext
}
public void TestMarshallPrecursorIds()
{
var subsegment = new Subsegment("test");
subsegment.Id = "1111111111111111";
subsegment.AddPrecursorId("2222222222222222");
subsegment.AddPrecursorId("2222222222222222");
subsegment.AddPrecursorId("3333333333333333");
var actual = _marshaller.Marshall(subsegment);
var expected = "{\"format\":\"json\",\"version\":1}\n{\"id\":\"1111111111111111\",\"start_time\":0,\"end_time\":0,\"name\":\"test\",\"precursor_ids\":[\"2222222222222222\",\"3333333333333333\"]}";
Assert.AreEqual(expected, actual);
}
public async Task TestAsyncGet()
{
var origin = new Subsegment("test");
AWSXRayRecorder.Instance.SetEntity(origin);
Entity later = null;
await Task.Run(() =>
{
later = AWSXRayRecorder.Instance.GetEntity();
});
Assert.ReferenceEquals(origin, later);
}
public async Task TestAsyncGet()
{
var origin = new Subsegment("test");
TraceContext.SetEntity(origin);
Entity later = null;
await Task.Run(() =>
{
later = TraceContext.GetEntity();
});
Assert.ReferenceEquals(origin, later);
}
public void TestNestedSubsegments()
{
_recorder.BeginSubsegment("subsegment1");
Subsegment child = (Subsegment)TraceContext.GetEntity();
FacadeSegment facadeSegment = (FacadeSegment)child.RootSegment;
_recorder.BeginSubsegment("subsegment2");
Assert.AreEqual("subsegment2", TraceContext.GetEntity().Name);
Assert.AreEqual(facadeSegment.TraceId, TraceContext.GetEntity().RootSegment.TraceId); //root segment of subsegment2 is facade segment
_recorder.EndSubsegment();
_recorder.EndSubsegment();
Assert.AreEqual(facadeSegment.GetType(), typeof(FacadeSegment));
Assert.IsFalse(facadeSegment.Subsegments.Contains(child)); //only subsegments are streamed
Assert.IsFalse(TraceContext.IsEntityPresent());
}
public void TestEndSubsegmentWithCustomTime()
{
AWSXRayRecorder recorder = new AWSXRayRecorderBuilder().Build();
recorder.BeginSubsegment("Subsegment1");
Subsegment subsegment = (Subsegment)recorder.TraceContext.GetEntity();
Assert.IsTrue(DateTime.UtcNow.ToUnixTimeSeconds() >= subsegment.StartTime);
var custom_time = new DateTime(2019, 07, 14);
recorder.EndSubsegment(custom_time);
Assert.AreEqual(1563062400, subsegment.EndTime);
}
public void TestMarshallMetadata()
{
var subsegment = new Subsegment("metadata");
subsegment.Id = "1111111111111111";
subsegment.AddMetadata("key1", "value1");
subsegment.AddMetadata("key2", "value2");
subsegment.AddMetadata("aws", "key1", "value1");
var actual = _marshaller.Marshall(subsegment);
var actualJson = JsonMapper.ToObject(actual.Split('\n')[1]);
Assert.AreEqual("value1", (string)actualJson["metadata"]["default"]["key1"]);
Assert.AreEqual("value2", (string)actualJson["metadata"]["default"]["key2"]);
Assert.AreEqual("value1", (string)actualJson["metadata"]["aws"]["key1"]);
}
private void AssertExpectedSqlInformation(Subsegment segment, bool isTrustedConn = false)
{
Assert.IsNotNull(segment);
Assert.IsNotNull(segment.Sql);
Assert.AreEqual("sqlserver", segment.Sql["database_type"]);
Assert.AreEqual(_command.Connection.ServerVersion, segment.Sql["database_version"]);
if (!isTrustedConn)
{
Assert.AreEqual(_userId, segment.Sql["user"]);
Assert.AreEqual(_sanitizedConnectionString, segment.Sql["connection_string"]);
}
else
{
Assert.AreEqual(_collectedTrustedConnectionString, segment.Sql["connection_string"]);
}
}
public void TestSegmentAndSubsegmentsWithNullSampleResponse()
{
_recorder.BeginSegment("parent", samplingResponse: null);
Segment parent = (Segment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.BeginSubsegment("child");
Subsegment child = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.EndSubsegment();
Assert.ReferenceEquals(AWSXRayRecorder.Instance.TraceContext.GetEntity(), parent);
_recorder.EndSegment();
Assert.ReferenceEquals(parent, child.Parent);
Assert.IsTrue(parent.Subsegments.Contains(child));
}
public void TestSegmentAndSubsegmentsWithNoTraceId()
{
_recorder.BeginSegment("parent");
Segment parent = (Segment)TraceContext.GetEntity();
_recorder.BeginSubsegment("child");
Subsegment child = (Subsegment)TraceContext.GetEntity();
_recorder.EndSubsegment();
Assert.ReferenceEquals(TraceContext.GetEntity(), parent);
_recorder.EndSegment();
Assert.ReferenceEquals(parent, child.Parent);
Assert.IsTrue(parent.Subsegments.Contains(child));
}
public void TestLambdaLeakedSubsegments()
{
String secondTraceHeader = "Root=" + Core.Internal.Entities.TraceId.NewId() + ";Parent=53995c3f42cd8ad1;Sampled=1";
_recorder.BeginSubsegment("subsegment1");
Subsegment subsegment1 = (Subsegment)TraceContext.GetEntity();
Environment.SetEnvironmentVariable(AWSXRayRecorder.LambdaTraceHeaderKey, secondTraceHeader);
_recorder.BeginSubsegment("subsegment2"); //Environment variables changed, subsegment1 will be dropped
Subsegment subsegment2 = (Subsegment)TraceContext.GetEntity();
FacadeSegment facadeSegment = (FacadeSegment)subsegment2.RootSegment;
Assert.IsFalse(facadeSegment.Subsegments.Contains(subsegment1)); //subsegment1 dropped
Assert.IsTrue(facadeSegment.Subsegments.Contains(subsegment2)); //only subsegment2 is present
_recorder.EndSubsegment(); //subsegment2 streamed
Assert.IsFalse(TraceContext.IsEntityPresent()); // Facade segment not present in the callcontext
}
public void TestMarshallHttp()
{
var subsegment = new Subsegment("test");
subsegment.Id = "1111111111111111";
var request = new Dictionary <string, string>();
request["url"] = @"http://hello-1.mbfzqxzcpe.us-east-1.elasticbeanstalk.com/foo";
request["method"] = "GET";
subsegment.Http["request"] = request;
var actual = _marshaller.Marshall(subsegment);
var expected = "{\"format\":\"json\",\"version\":1}\n{\"id\":\"1111111111111111\",\"start_time\":0,\"end_time\":0,\"name\":\"test\",\"http\":{\"request\":{\"url\":\"http://hello-1.mbfzqxzcpe.us-east-1.elasticbeanstalk.com/foo\",\"method\":\"GET\"}}}";
Assert.AreEqual(expected, actual);
}
public void TestSyncCreateSegmentAndSubsegments()
{
_recorder.BeginSegment("parent", TraceId);
Segment parent = (Segment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.BeginSubsegment("child");
Subsegment child = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.EndSubsegment();
Assert.ReferenceEquals(AWSXRayRecorder.Instance.TraceContext.GetEntity(), parent);
_recorder.EndSegment();
Assert.ReferenceEquals(parent, child.Parent);
Assert.IsTrue(parent.Subsegments.Contains(child));
}
public void TestMarshallError()
{
try
{
throw new ArgumentNullException("value");
}
catch (ArgumentNullException)
{
var subsegment = new Subsegment("test");
subsegment.Id = "1111111111111111";
subsegment.HasError = true;
var actual = _marshaller.Marshall(subsegment);
var expected = "{\"format\":\"json\",\"version\":1}\n{\"id\":\"1111111111111111\",\"start_time\":0,\"end_time\":0,\"name\":\"test\",\"error\":true}";
Assert.AreEqual(expected, actual);
}
}
public void TestSegmentAndSubsegmentsWithNoTraceId()
{
_recorder.BeginSegment("parent");
Segment parent = (Segment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.BeginSubsegment("child");
Subsegment child = (Subsegment)AWSXRayRecorder.Instance.TraceContext.GetEntity();
_recorder.EndSubsegment();
Assert.ReferenceEquals(AWSXRayRecorder.Instance.TraceContext.GetEntity(), parent);
_recorder.EndSegment();
Assert.AreEqual(SampleDecision.Sampled, parent.Sampled);
Assert.ReferenceEquals(parent, child.Parent);
Assert.IsTrue(parent.Subsegments.Contains(child));
}
