public void TraceCounter(HttpTracingActivity tracing, Dictionary <string, EventCounterData> counterData)
{
foreach (var eventCounterData in counterData)
{
tracing[Counters[eventCounterData.Key]] = eventCounterData.Value.Mean;
}
}
private static void AssertConfig(HttpTracingActivity httpActivity, string serviceName)
{
AssertTag(httpActivity, "name", Is.EqualTo(serviceName));
AssertTag(httpActivity, "maxConnection", Is.EqualTo(100));
AssertTag(httpActivity, "schema", Is.EqualTo("http"));
}
public void TraceEnd(HttpTracingActivity activity)
{
activity[RequestStart] = activity.Activity.StartTimeUtc;
activity[RequestEnd] = EndTime(activity.Activity);
activity[TotalTime] = activity.Activity.Duration;
if (activity.HttpActivity != null)
{
activity[HttpRequestStart] = activity.HttpActivity.StartTimeUtc;
activity[HttpRequestEnd] = EndTime(activity.HttpActivity);
activity[HttpTotalTime] = activity.HttpActivity.Duration;
activity[HandlerDeltaOnStart] = (activity.HttpActivity.StartTimeUtc - activity.Activity.StartTimeUtc).TotalMilliseconds;
activity[HandlerDeltaOnEnd] = (EndTime(activity.Activity) - EndTime(activity.HttpActivity)).TotalMilliseconds;
activity[HandlerDelta] = (activity.Activity.Duration - activity.HttpActivity.Duration).TotalMilliseconds;
foreach (var httpActivityTag in activity.HttpActivity.Tags)
{
activity[httpActivityTag.Key] = httpActivityTag.Value;
}
}
DateTime EndTime(Activity a) => a.StartTimeUtc.Add(a.Duration);
}
public void Tag(HttpTracingActivity tags)
{
if (Enabled && Value != null)
{
tags[Name] = Value.Invoke(tags);
}
}
private void AssertRequest(HttpTracingActivity httpActivity, string path)
{
AssertTag(httpActivity, "r.schema", Is.EqualTo("http"));
AssertTag(httpActivity, "host", Is.EqualTo("127.0.0.1"));
AssertTag(httpActivity, "path", Is.EqualTo(path));
AssertTag(httpActivity, OpenTelemetryConventions.AttributeHttpMethod, Is.EqualTo("GET"));
AssertTag(httpActivity, OpenTelemetryConventions.AttributeHttpUrl, Is.EqualTo(_server.Url(path)));
}
public void EnrichException(HttpTracingActivity ctx,
Exception requestMessage)
{
foreach (var enrichment in ErrorEnrichment)
{
enrichment.OnException(ctx, requestMessage);
}
}
public void EnrichRequest(HttpTracingActivity ctx,
HttpWebRequest requestMessage)
{
foreach (var enrichment in RequestEnrichment)
{
enrichment.OnHttpRequest(ctx, requestMessage);
}
}
public void EnrichResponse(HttpTracingActivity ctx,
HttpResponseMessage responseMessage)
{
foreach (var enrichment in ResponseEnrichment)
{
enrichment.OnHttpResponse(ctx, responseMessage);
}
}
public void Trace(HttpTracingActivity tracing)
{
tracing[Server] = tracing.ClientOptions.Connection?.Server.NullOr(string.Intern);
tracing[Port] = tracing.ClientOptions.Connection?.Port.ToString().NullOr(string.Intern);
tracing[Schema] = tracing.ClientOptions.Connection?.Schema.NullOr(string.Intern);
tracing[Name] = tracing.ClientOptions.ServiceName.NullOr(string.Intern);
tracing[Timeout] = tracing.ClientOptions.Timeout?.Timeout.TotalMilliseconds;
tracing[MaxConnection] = tracing.ClientOptions.Handler?.MaxConnection;
tracing[LifeTimeMinutes] = tracing.ClientOptions.Handler?.HandlerLifeTimeMinutes;
}
public void Trace(HttpTracingActivity tracing, HttpRequestMessage request)
{
tracing[Method] = request.Method.ToString();
tracing[Url] = request.RequestUri?.AbsoluteUri.NullOr(string.Intern);
tracing[Schema] = request.RequestUri?.Scheme.NullOr(string.Intern);
tracing[Host] = request.RequestUri?.Host.NullOr(string.Intern);
tracing[RequestPath] = request.RequestUri?.AbsolutePath.NullOr(string.Intern);
tracing[RequestLength] = request.Content?.Headers.ContentLength;
tracing[Port] = request.RequestUri?.Port;
}
private void AssertConnection(HttpTracingActivity httpActivity)
{
#if NETFRAMEWORK
AssertTag(httpActivity, "connection.count", Is.GreaterThanOrEqualTo(1));
AssertTag(httpActivity, "connection.limit", Is.GreaterThanOrEqualTo(100));
AssertTag(httpActivity, "connection.timeout", Is.GreaterThanOrEqualTo(-1));
AssertTag(httpActivity, "connection.idleSince", Is.Not.Null);
AssertTag(httpActivity, "connection.maxIdleTime", Is.GreaterThanOrEqualTo(100000));
AssertTag(httpActivity, "connection.useNagle", Is.True);
#endif
}
private void TraceWebRequest(HttpTracingActivity tracing, HttpWebRequest request)
{
tracing[Method] = request.Method;
tracing[Url] = request.RequestUri?.AbsoluteUri.NullOr(string.Intern);
tracing[Schema] = request.RequestUri?.Scheme.NullOr(string.Intern);
tracing[Host] = request.RequestUri?.Host.NullOr(string.Intern);
tracing[RequestPath] = request.RequestUri?.AbsolutePath.NullOr(string.Intern);
tracing[Port] = request.RequestUri?.Port;
tracing[RequestLength] = request.ContentLength;
tracing[RequestLength] = request.Connection;
}
public void Trace(HttpTracingActivity activity, Exception exception)
{
activity[Type] = exception.GetType();
activity[Error] = exception.Message;
activity[StackTrace] = exception.StackTrace;
if (exception.InnerException != null)
{
activity[InnerError] = exception.InnerException.Message;
activity[InnerType] = exception.InnerException.GetType();
activity[InnerStackTrace] = exception.InnerException.StackTrace;
}
}
public void Trace(HttpTracingActivity activity)
{
if (Enabled)
{
foreach (var tracingTag in
ConnectionState
.Append(AllConnections)
.Append(TotalConnection))
{
tracingTag.Tag(activity);
}
}
}
public void Trace(HttpTracingActivity tracing, HttpWebRequest request)
{
var servicePoint = request.ServicePoint;
tracing[Count] = servicePoint.CurrentConnections;
tracing[ConnectionsLimit] = servicePoint.ConnectionLimit;
tracing[ConnectionsTimeout] = servicePoint.ConnectionLeaseTimeout;
tracing[IdleSince] = servicePoint.IdleSince;
tracing[MaxIdleTime] = servicePoint.MaxIdleTime;
tracing[ReceiveBufferSize] = servicePoint.ReceiveBufferSize;
tracing[UseNagleAlgorithm] = servicePoint.UseNagleAlgorithm;
tracing[ConnectionId] = request.Connection;
tracing[ConnectionGroup] = request.ConnectionGroupName;
}
public async Task HttpTracing_SanityTest()
{
var serviceName = "service";
var client = _factory.CreateClient(serviceName);
var timing = await Time(() => client.GetAsync("/delay/200ms"));
HttpTracingActivity tracingCtx = LastActivity(serviceName);
Assert.NotNull(tracingCtx);
Assert.Multiple(() =>
{
timing.AssertTime(tracingCtx);
AssertConfig(tracingCtx, serviceName);
AssertRequest(tracingCtx, "/delay/200ms");
AssertResponse(tracingCtx, 200);
AssertConnection(tracingCtx);
});
}
public void AssertTime(HttpTracingActivity httpActivity)
{
// Assert.That(httpActivity.Timestamp, Is.EqualTo(Timestamp).Within(20000),
// $"timestamp differ by {Timestamp - httpActivity.Timestamp}");
Assert.That(httpActivity.StartTime, Is.EqualTo(StartDate).Within(20).Milliseconds, "startTime");
Assert.That(httpActivity.EndTime, Is.EqualTo(EndTime).Within(20).Milliseconds, "endTime");
Assert.That(httpActivity.TotalTime, Is.EqualTo(Stopwatch.Elapsed).Within(300).Milliseconds,
"totalTime");
AssertTag(httpActivity, "timestamp", Is.EqualTo(httpActivity.Timestamp));
AssertTag(httpActivity, "time.start", Is.EqualTo(httpActivity.Activity.StartTimeUtc));
AssertTag(httpActivity, "time.end",
Is.EqualTo(httpActivity.Activity.StartTimeUtc.Add(httpActivity.Activity.Duration)));
AssertTag(httpActivity, "time.duration", Is.EqualTo(httpActivity.Activity.Duration));
AssertTag(httpActivity, "time.http.start", Is.EqualTo(httpActivity.HttpActivity.StartTimeUtc));
AssertTag(httpActivity, "time.http.end",
Is.EqualTo(httpActivity.HttpActivity.StartTimeUtc.Add(httpActivity.HttpActivity.Duration)));
AssertTag(httpActivity, "time.http.duration", Is.EqualTo(httpActivity.HttpActivity.Duration));
}
public void TraceWebResponse(HttpTracingActivity activity, HttpWebResponse httpResponseMessage)
{
activity[ContentLength] = httpResponseMessage.ContentLength;
activity[HttpStatusCode] = (int)httpResponseMessage.StatusCode;
}
public void OnHttpRequest(HttpTracingActivity activity, HttpRequestMessage request)
{
_onRequest?.Invoke(activity, request);
}
public void OnHttpResponse(HttpTracingActivity activity, HttpWebResponse response)
{
_onWebResponse?.Invoke(activity, response);
}
public void OnHttpResponse(HttpTracingActivity activity, HttpResponseMessage response)
{
_onResponse?.Invoke(activity, response);
}
public void OnHttpRequest(HttpTracingActivity activity, HttpWebRequest request)
{
_onWebRequest?.Invoke(activity, request);
}
public void Export(HttpTracingActivity activity)
{
_tracingActivityExporter(activity);
}
public void OnException(HttpTracingActivity activity, Exception exception)
{
_onException?.Invoke(activity, exception);
}
public void TraceStart(HttpTracingActivity activity)
{
activity[CorrelationsId] = activity.CorrelationId;
activity[Timestamp] = activity.Timestamp;
}
private static void AssertResponse(HttpTracingActivity httpActivity, int statusCode)
{
AssertTag(httpActivity, OpenTelemetryConventions.AttributeHttpStatusCode, Is.EqualTo(statusCode));
}
private static void AssertTag(HttpTracingActivity activity, string name, IConstraint constraint)
{
activity.Tags.TryGetValue(name, out var tag);
Assert.That(tag, constraint, name);
}
