public void TransactionWithRequestDetailed()
{
var payloadSender = AssertWith1Transaction(
n =>
{
n.Tracer.CaptureTransaction(TransactionName, TransactionType, transaction =>
{
WaitHelpers.SleepMinimum();
transaction.Context.Request =
new Request("GET",
new Url {
Full = "https://elastic.co", Raw = "https://elastic.co", HostName = "elastic", Protocol = "HTTP"
})
{
HttpVersion = "2.0",
Socket = new Socket {
Encrypted = true, RemoteAddress = "127.0.0.1"
},
Body = "123"
};
});
});
payloadSender.FirstTransaction.Context.Request.Method.Should().Be("GET");
payloadSender.FirstTransaction.Context.Request.Url.Protocol.Should().Be("HTTP");
payloadSender.FirstTransaction.Context.Request.HttpVersion.Should().Be("2.0");
payloadSender.FirstTransaction.Context.Request.Socket.Encrypted.Should().BeTrue();
payloadSender.FirstTransaction.Context.Request.Url.Full.Should().Be("https://elastic.co");
payloadSender.FirstTransaction.Context.Request.Url.Raw.Should().Be("https://elastic.co");
payloadSender.FirstTransaction.Context.Request.Socket.RemoteAddress.Should().Be("127.0.0.1");
payloadSender.FirstTransaction.Context.Request.Url.HostName.Should().Be("elastic");
payloadSender.FirstTransaction.Context.Request.Body.Should().Be("123");
}
/// <summary>
/// Asserts on 1 transaction with 1 span and 1 error
/// </summary>
private void AssertWith1TransactionAnd1SpanAnd1Error(Action <ITransaction> action)
{
var payloadSender = new MockPayloadSender();
using (var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender)))
{
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, t =>
{
WaitHelpers.SleepMinimum();
action(t);
});
}
payloadSender.WaitForTransactions();
payloadSender.Transactions.Should().NotBeEmpty();
payloadSender.FirstTransaction.Name.Should().Be(TransactionName);
payloadSender.FirstTransaction.Type.Should().Be(TransactionType);
var duration = payloadSender.FirstTransaction.Duration;
duration.Should().BeGreaterOrEqualToMinimumSleepLength(3);
payloadSender.WaitForSpans();
payloadSender.SpansOnFirstTransaction.Should().NotBeEmpty();
payloadSender.SpansOnFirstTransaction[0].Name.Should().Be(SpanName);
payloadSender.SpansOnFirstTransaction[0].Type.Should().Be(SpanType);
payloadSender.WaitForErrors();
payloadSender.Errors.Should().NotBeEmpty();
payloadSender.FirstError.Exception.Type.Should().Be(typeof(InvalidOperationException).FullName);
payloadSender.FirstError.Exception.Message.Should().Be(ExceptionMessage);
}
/// <summary>
/// Asserts on 1 transaction with 1 span and 1 error
/// </summary>
private void AssertWith1TransactionAnd1SpanAnd1Error(Action <ITransaction> action)
{
var payloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender));
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, t =>
{
WaitHelpers.SleepMinimum();
action(t);
});
Assert.NotEmpty(payloadSender.Payloads);
Assert.NotEmpty(payloadSender.Payloads[0].Transactions);
Assert.Equal(TransactionName, payloadSender.Payloads[0].Transactions[0].Name);
Assert.Equal(TransactionType, payloadSender.Payloads[0].Transactions[0].Type);
var duration = payloadSender.Payloads[0].Transactions[0].Duration;
WaitHelpers.Assert3XMinimumSleepLength(duration);
Assert.NotEmpty(payloadSender.SpansOnFirstTransaction);
Assert.Equal(SpanName, payloadSender.SpansOnFirstTransaction[0].Name);
Assert.Equal(SpanType, payloadSender.SpansOnFirstTransaction[0].Type);
Assert.NotEmpty(payloadSender.Errors);
Assert.NotEmpty(payloadSender.Errors[0].Errors);
Assert.Equal(typeof(InvalidOperationException).FullName, payloadSender.Errors[0].Errors[0].Exception.Type);
Assert.Equal(ExceptionMessage, payloadSender.Errors[0].Errors[0].Exception.Message);
}
public void DistributedTracingDataWitSimpleActionWithParameter_Invalid(string traceId, string parentId, string traceFlags) =>
AssertInvalidDistributedTracingData(agent => agent.Tracer.CaptureTransaction(TestTransaction,
UnitTest, t =>
{
t.Should().NotBeNull();
WaitHelpers.SleepMinimum();
}, BuildDistributedTracingData(traceId, parentId, traceFlags)), traceId);
/// <summary>
/// Asserts on 1 transaction with 1 span
/// </summary>
private MockPayloadSender AssertWith1TransactionAnd1Span(Action <ITransaction> action)
{
var payloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender));
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, t =>
{
WaitHelpers.SleepMinimum();
action(t);
});
Assert.NotEmpty(payloadSender.Payloads);
Assert.NotEmpty(payloadSender.Payloads[0].Transactions);
Assert.Equal(TransactionName, payloadSender.Payloads[0].Transactions[0].Name);
Assert.Equal(TransactionType, payloadSender.Payloads[0].Transactions[0].Type);
Assert.NotEmpty(payloadSender.SpansOnFirstTransaction);
Assert.Equal(SpanName, payloadSender.SpansOnFirstTransaction[0].Name);
Assert.Equal(SpanType, payloadSender.SpansOnFirstTransaction[0].Type);
var duration = payloadSender.Payloads[0].Transactions[0].Duration;
WaitHelpers.Assert3XMinimumSleepLength(duration);
return(payloadSender);
}
public void FillSpanContext()
{
var payloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender));
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, t =>
{
WaitHelpers.SleepMinimum();
t.CaptureSpan("SampleSpan1", "SampleSpanType",
span => { span.Context.Http = new Http {
Url = "http://mysite.com", Method = "GET", StatusCode = 200
}; });
t.CaptureSpan("SampleSpan2", "SampleSpanType",
span =>
{
span.Context.Db = new Database {
Statement = "Select * from MyTable", Type = Database.TypeSql, Instance = "MyInstance"
};
});
});
payloadSender.Spans[0].Name.Should().Be("SampleSpan1");
payloadSender.Spans[0].Context.Http.Url.Should().Be("http://mysite.com");
payloadSender.Spans[0].Context.Http.Method.Should().Be("GET");
payloadSender.Spans[0].Context.Http.StatusCode.Should().Be(200);
payloadSender.Spans[0].Context.Destination.Address.Should().Be("mysite.com");
payloadSender.Spans[0].Context.Destination.Port.Should().Be(UrlUtilsTests.DefaultHttpPort);
payloadSender.Spans[1].Name.Should().Be("SampleSpan2");
payloadSender.Spans[1].Context.Db.Statement.Should().Be("Select * from MyTable");
payloadSender.Spans[1].Context.Db.Type.Should().Be(Database.TypeSql);
payloadSender.Spans[1].Context.Db.Instance.Should().Be("MyInstance");
}
/// <summary>
/// Asserts on 1 transaction with 1 span
/// </summary>
private MockPayloadSender AssertWith1TransactionAnd1Span(Action <ITransaction> action)
{
var payloadSender = new MockPayloadSender();
var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender));
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, t =>
{
WaitHelpers.SleepMinimum();
action(t);
});
payloadSender.WaitForTransactions();
payloadSender.Transactions.Should().NotBeEmpty();
payloadSender.FirstTransaction.Name.Should().Be(TransactionName);
payloadSender.FirstTransaction.Type.Should().Be(TransactionType);
payloadSender.WaitForSpans();
payloadSender.SpansOnFirstTransaction.Should().NotBeEmpty();
payloadSender.SpansOnFirstTransaction[0].Name.Should().Be(SpanName);
payloadSender.SpansOnFirstTransaction[0].Type.Should().Be(SpanType);
var duration = payloadSender.FirstTransaction.Duration;
duration.Should().BeGreaterOrEqualToMinimumSleepLength(3);
return(payloadSender);
}
public void SimpleActionWithReturnTypeAndParameter_Valid() =>
AssertValidDistributedTracingData(agent => agent.Tracer.CaptureTransaction(TestTransaction, UnitTest,
t =>
{
t.Should().NotBeNull();
WaitHelpers.SleepMinimum();
return(42);
}, BuildDistributedTracingData(ValidTraceId, ValidParentId, ValidTraceFlags)));
public void SimpleActionWithParameter() => AssertWith1Transaction(agent =>
{
agent.Tracer.CaptureTransaction(TransactionName, TransactionType,
t =>
{
t.Should().NotBeNull();
WaitHelpers.SleepMinimum();
});
});
public void SimpleActionWithReturnType() => AssertWith1Transaction(agent =>
{
var res = agent.Tracer.CaptureTransaction(TransactionName, TransactionType, () =>
{
WaitHelpers.SleepMinimum();
return(42);
});
res.Should().Be(42);
});
public void SimpleActionWithException() => AssertWith1TransactionAnd1Error(agent =>
{
Assert.Throws <InvalidOperationException>(() =>
{
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, new Action(() =>
{
WaitHelpers.SleepMinimum();
throw new InvalidOperationException(ExceptionMessage);
}));
});
});
/// <summary>
/// Asserts on 1 transaction with 1 span and 1 error
/// </summary>
private void AssertWith1TransactionAnd1SpanAnd1ErrorOnSubSpan(Action <ISpan> action)
{
var payloadSender = new MockPayloadSender();
using (var agent = new ApmAgent(new TestAgentComponents(payloadSender: payloadSender)))
{
WaitHelpers.SleepMinimum();
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, t =>
{
WaitHelpers.SleepMinimum();
t.CaptureSpan("aa", "bb", s =>
{
WaitHelpers.SleepMinimum();
action(s);
});
});
}
payloadSender.WaitForTransactions();
payloadSender.Transactions.Should().NotBeEmpty();
payloadSender.FirstTransaction.Name.Should().Be(TransactionName);
payloadSender.FirstTransaction.Type.Should().Be(TransactionType);
var duration = payloadSender.FirstTransaction.Duration;
duration.Should().BeGreaterOrEqualToMinimumSleepLength(3);
payloadSender.WaitForSpans();
payloadSender.SpansOnFirstTransaction.Should().NotBeEmpty();
payloadSender.SpansOnFirstTransaction[0].Name.Should().Be(SpanName);
payloadSender.SpansOnFirstTransaction[0].Type.Should().Be(SpanType);
payloadSender.WaitForErrors();
payloadSender.Errors.Should().NotBeEmpty();
payloadSender.Errors.Should().NotBeEmpty();
payloadSender.FirstError.Exception.Type.Should().Be(typeof(InvalidOperationException).FullName);
payloadSender.FirstError.Exception.Message.Should().Be(ExceptionMessage);
var orderedSpans = payloadSender.Spans.OrderBy(n => n.Timestamp).ToList();
var firstSpan = orderedSpans.First();
var innerSpan = orderedSpans.Last();
firstSpan.ParentId.Should().Be(payloadSender.FirstTransaction.Id);
innerSpan.ParentId.Should().Be(firstSpan.Id);
firstSpan.TransactionId.Should().Be(payloadSender.FirstTransaction.Id);
innerSpan.TransactionId.Should().Be(payloadSender.FirstTransaction.Id);
}
public void SimpleActionWithReturnTypeAndParameter() => AssertWith1Transaction(agent =>
{
var res = agent.Tracer.CaptureTransaction(TransactionName, TransactionType,
t =>
{
Assert.NotNull(t);
WaitHelpers.SleepMinimum();
return(42);
});
Assert.Equal(42, res);
});
public void SimpleActionWithReturnTypeAndParameter() => AssertWith1Transaction(agent =>
{
var res = agent.Tracer.CaptureTransaction(TransactionName, TransactionType,
t =>
{
t.Should().NotBeNull();
WaitHelpers.SleepMinimum();
return(42);
});
res.Should().Be(42);
});
public void SimpleActionWithExceptionAndParameter() => AssertWith1TransactionAnd1Error(agent =>
{
Action act = () =>
{
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, new Action <ITransaction>(t =>
{
t.Should().NotBeNull();
WaitHelpers.SleepMinimum();
throw new InvalidOperationException(ExceptionMessage);
}));
};
act.Should().Throw <InvalidOperationException>();
});
public void TransactionWithRequest()
{
var payloadSender = AssertWith1Transaction(
n =>
{
n.Tracer.CaptureTransaction(TransactionName, TransactionType, transaction =>
{
WaitHelpers.SleepMinimum();
transaction.Context.Request = new Request("GET", new Url {
Protocol = "HTTP"
});
});
});
payloadSender.FirstTransaction.Context.Request.Method.Should().Be("GET");
payloadSender.FirstTransaction.Context.Request.Url.Protocol.Should().Be("HTTP");
}
public void TransactionWithResponse()
{
var payloadSender = AssertWith1Transaction(
n =>
{
n.Tracer.CaptureTransaction(TransactionName, TransactionType, transaction =>
{
WaitHelpers.SleepMinimum();
transaction.Context.Response = new Response {
Finished = true, StatusCode = 200
};
});
});
payloadSender.FirstTransaction.Context.Response.Finished.Should().BeTrue();
payloadSender.FirstTransaction.Context.Response.StatusCode.Should().Be(200);
}
public void TagsOnTransaction()
{
var payloadSender = AssertWith1Transaction(
t =>
{
t.Tracer.CaptureTransaction(TransactionName, TransactionType, transaction =>
{
WaitHelpers.SleepMinimum();
transaction.Tags["foo"] = "bar";
});
});
//According to the Intake API tags are stored on the Context (and not on Transaction.Tags directly).
Assert.Equal("bar", payloadSender.FirstTransaction.Context.Tags["foo"]);
//Also make sure the tag is visible directly on Transaction.Tags.
Assert.Equal("bar", payloadSender.Payloads[0].Transactions[0].Tags["foo"]);
}
public void LabelsOnTransaction()
{
var payloadSender = AssertWith1Transaction(
t =>
{
t.Tracer.CaptureTransaction(TransactionName, TransactionType, transaction =>
{
WaitHelpers.SleepMinimum();
transaction.Labels["foo"] = "bar";
});
});
//According to the Intake API labels are stored on the Context (and not on Transaction.Labels directly).
payloadSender.FirstTransaction.Context.Labels.Should().Contain("foo", "bar");
//Also make sure the label is visible directly on Transaction.Labels.
payloadSender.FirstTransaction.Labels.Should().Contain("foo", "bar");
}
public void SimpleActionWithReturnTypeAndException() => AssertWith1TransactionAnd1Error(agent =>
{
Action act = () =>
{
agent.Tracer.CaptureTransaction(TransactionName, TransactionType, () =>
{
WaitHelpers.SleepMinimum();
if (new Random().Next(1) == 0) //avoid unreachable code warning.
{
throw new InvalidOperationException(ExceptionMessage);
}
return(42);
});
throw new Exception("CaptureTransaction should not eat exception and continue");
};
act.Should().Throw <InvalidOperationException>();
});
public void SimpleActionWithReturnTypeAndException() => AssertWith1TransactionAnd1Error(agent =>
{
Assert.Throws <InvalidOperationException>(() =>
{
var result = agent.Tracer.CaptureTransaction(TransactionName, TransactionType, () =>
{
WaitHelpers.SleepMinimum();
if (new Random().Next(1) == 0) //avoid unreachable code warning.
{
throw new InvalidOperationException(ExceptionMessage);
}
return(42);
});
Assert.True(false); //Should not be executed because the agent isn't allowed to catch an exception.
Assert.Equal(42, result); //But if it'd not throw it'd be 42.
});
});
public void TransactionWithUser()
{
const string userId = "123";
const string userName = "******";
const string emailAddress = "*****@*****.**";
var payloadSender = AssertWith1Transaction(
n =>
{
n.Tracer.CaptureTransaction(TransactionName, TransactionType, transaction =>
{
WaitHelpers.SleepMinimum();
transaction.Context.User = new User {
Id = userId, UserName = userName, Email = emailAddress
};
});
});
payloadSender.FirstTransaction.Context.User.Id.Should().Be(userId);
payloadSender.FirstTransaction.Context.User.UserName.Should().Be(userName);
payloadSender.FirstTransaction.Context.User.Email.Should().Be(emailAddress);
}
public void TransactionWithResponseAndRequest()
{
var payloadSender = AssertWith1Transaction(
n =>
{
n.Tracer.CaptureTransaction(TransactionName, TransactionType, transaction =>
{
WaitHelpers.SleepMinimum();
transaction.Context.Response = new Response {
Finished = true
};
transaction.Context.Request = new Request("GET", new Url());
transaction.Context.Response.StatusCode = 200;
transaction.Context.Request.Url.Full = "https://elastic.co";
});
});
payloadSender.FirstTransaction.Context.Response.Finished.Should().BeTrue();
payloadSender.FirstTransaction.Context.Response.StatusCode.Should().Be(200);
payloadSender.FirstTransaction.Context.Request.Url.Full.Should().Be("https://elastic.co");
}
public void SimpleAction() => AssertWith1Transaction(agent =>
{
agent.Tracer.CaptureTransaction(TransactionName, TransactionType,
() => { WaitHelpers.SleepMinimum(); });
});
public void DistributedTracingDataWithSimpleAction_Valid() =>
AssertValidDistributedTracingData(agent => agent.Tracer.CaptureTransaction(TestTransaction,
UnitTest, () => { WaitHelpers.SleepMinimum(); }, BuildDistributedTracingData(ValidTraceId, ValidParentId, ValidTraceFlags)));
public void DistributedTracingDataWithSimpleAction_Invalid(string traceId, string parentId, string traceFlags) =>
AssertInvalidDistributedTracingData(agent => agent.Tracer.CaptureTransaction(TestTransaction,
UnitTest, () => { WaitHelpers.SleepMinimum(); }, BuildDistributedTracingData(traceId, parentId, traceFlags)), traceId);
