public ISpan OnBeginRequest(HttpContext httpContext)
{
var spanBuilder = new SpanBuilder($"server {httpContext.Request.Method} {httpContext.Request.Path}");
if (_tracer.Tracer.TryExtract(out var spanContext, httpContext.Request.Headers, (c, k) => c[k].GetValue(),
c => c.Select(x => new KeyValuePair <string, string>(x.Key, x.Value.GetValue())).GetEnumerator()))
{
spanBuilder.AsChildOf(spanContext);
}
var span = _tracer.Start(spanBuilder);
httpContext.SetSpan(span);
span.Log(LogField.CreateNew().ServerReceive());
span.Log(LogField.CreateNew().Event("AspNetCore BeginRequest"));
span.Tags
.Server().Component("AspNetCore")
.HttpMethod(httpContext.Request.Method)
.HttpUrl($"{httpContext.Request.Scheme}://{httpContext.Request.Host.ToUriComponent()}{httpContext.Request.Path}{httpContext.Request.QueryString}")
.HttpHost(httpContext.Request.Host.ToUriComponent())
.HttpPath(httpContext.Request.Path)
.HttpStatusCode(httpContext.Response.StatusCode)
.PeerAddress(httpContext.Connection.RemoteIpAddress.ToString())
.PeerPort(httpContext.Connection.RemotePort);
_tracer.Tracer.SetCurrentSpan(span);
return(span);
}
public void HttpRequest([Property(Name = "Request")] HttpRequestMessage request)
{
var patterns = _options.IgnoredRoutesRegexPatterns;
if (patterns == null || patterns.Any(x => Regex.IsMatch(request.RequestUri.AbsolutePath, x)))
{
return;
}
var spanBuilder = new SpanBuilder($"httpclient {request.Method}");
var spanContext = _tracer.Tracer.GetEntrySpan()?.SpanContext;
if (spanContext != null)
{
spanBuilder.AsChildOf(spanContext);
}
var span = _tracer.Start(spanBuilder);
span.Tags.Client().Component("HttpClient")
.HttpMethod(request.Method.Method)
.HttpUrl(request.RequestUri.OriginalString)
.HttpHost(request.RequestUri.Host)
.HttpPath(request.RequestUri.PathAndQuery)
.PeerAddress(request.RequestUri.OriginalString)
.PeerHostName(request.RequestUri.Host)
.PeerPort(request.RequestUri.Port);
_tracer.Tracer.Inject(span.SpanContext, request.Headers, (c, k, v) => c.Add(k, v));
span.Log(LogField.CreateNew().ClientSend());
if (request.Method == HttpMethod.Post)
{
span.Tags.Add("request", request.Content.ReadAsStringAsync().Result);
}
_tracer.Tracer.SetExitSpan(span);
}
private void Initialization()
{
ITracer tracer = new Tracer(recorder);
IServiceTracer serviceTracer = new ServiceTracer(tracer, "benckmark", "debug", "Butterfly.Client.Benckmark.Formatter");
for (var i = 0; i < 250; i++)
{
using (var span = serviceTracer.Start("parent"))
{
span.Log(LogField.CreateNew().ServerReceive());
span.Tags
.Server().Component("AspNetCore")
.HttpMethod("method")
.HttpUrl("url")
.HttpHost("host")
.HttpPath("path")
.HttpStatusCode(200)
.PeerAddress("ip")
.PeerPort(8080);
span.Log(LogField.CreateNew().ServerSend());
using (var child = serviceTracer.StartChild("child"))
{
}
}
}
}
public void HttpResponse([Property(Name = "Response")] HttpResponseMessage response)
{
if (response == null)
{
return;
}
var span = _tracer.Tracer.GetExitSpan();
if (span == null)
{
return;
}
span.Log(LogField.CreateNew().ClientReceive());
span.Tags.HttpStatusCode((int)response.StatusCode);
if (_options.TraceHttpContent && response.Content != null)
{
var result = response.Content.ReadAsStringAsync().Result;
if (result.Length > 2048)
{
result = result.Substring(0, 2048) + "...";
}
if (!string.IsNullOrWhiteSpace(result))
{
span.Tags.Add("http.response", _tbbrRegex.Replace(result, ""));
}
}
span.Finish();
_tracer.Tracer.SetExitSpan(null);
}
protected override async Task <HttpResponseMessage> TracingSendAsync(
ISpan span,
HttpRequestMessage request,
CancellationToken cancellationToken,
Action <string> addTraceIdToRepo,
Func <HttpRequestMessage, CancellationToken, Task <HttpResponseMessage> > baseSendAsync)
{
if (request.Headers.Contains(PrefixSpanId))
{
request.Headers.Remove(PrefixSpanId);
request.Headers.TryAddWithoutValidation(PrefixSpanId, span.SpanContext.SpanId);
}
addTraceIdToRepo(span.SpanContext.TraceId);
span.Log(LogField.CreateNew().ClientSend());
var responseMessage = await baseSendAsync(request, cancellationToken);
span.Log(LogField.CreateNew().ClientReceive());
await Task.Run(() => SendSpan(span, request, responseMessage));
return(responseMessage);
}
public void Event(HttpContext httpContext, string @event)
{
// todo - if the user isnt using tracing the code gets here and will blow up on
// _tracer.Tracer.TryExtract..
if (_tracer == null)
{
return;
}
var span = httpContext.GetSpan();
if (span == null)
{
var spanBuilder = new SpanBuilder($"server {httpContext.Request.Method} {httpContext.Request.Path}");
if (_tracer.Tracer.TryExtract(out var spanContext, httpContext.Request.Headers, (c, k) => c[k].GetValue(),
c => c.Select(x => new KeyValuePair <string, string>(x.Key, x.Value.GetValue())).GetEnumerator()))
{
spanBuilder.AsChildOf(spanContext);
}
span = _tracer.Start(spanBuilder);
httpContext.SetSpan(span);
}
span?.Log(LogField.CreateNew().Event(@event));
}
protected virtual async Task <HttpResponseMessage> TracingSendAsync(ISpan span, HttpRequestMessage request, CancellationToken cancellationToken)
{
IEnumerable <string> traceIdVals = null;
if (request.Headers.TryGetValues(prefix_spanId, out traceIdVals))
{
request.Headers.Remove(prefix_spanId);
request.Headers.TryAddWithoutValidation(prefix_spanId, span.SpanContext.SpanId);
}
span.Tags.Client().Component("HttpClient")
.HttpMethod(request.Method.Method)
.HttpUrl(request.RequestUri.OriginalString)
.HttpHost(request.RequestUri.Host)
.HttpPath(request.RequestUri.PathAndQuery)
.PeerAddress(request.RequestUri.OriginalString)
.PeerHostName(request.RequestUri.Host)
.PeerPort(request.RequestUri.Port);
_tracer.Tracer.Inject(span.SpanContext, request.Headers, (c, k, v) =>
{
if (!c.Contains(k))
{
c.Add(k, v);
}
});
span.Log(LogField.CreateNew().ClientSend());
var responseMessage = await base.SendAsync(request, cancellationToken);
span.Log(LogField.CreateNew().ClientReceive());
return(responseMessage);
}
private void Event(HttpContext httpContext, string @event)
{
// todo - if the user isnt using tracing the code gets here and will blow up on
// _tracer.Tracer.TryExtract. We already use the fake tracer for another scenario
// so sticking it here as well..I guess we need a factory for this but cba to do it at
// the moment
if (_tracer.GetType() == typeof(FakeServiceTracer))
{
return;
}
var span = httpContext.GetSpan();
if (span == null)
{
var spanBuilder = new SpanBuilder($"server {httpContext.Request.Method} {httpContext.Request.Path}");
if (_tracer.Tracer.TryExtract(out var spanContext, httpContext.Request.Headers, (c, k) => c[k].GetValue(),
c => c.Select(x => new KeyValuePair <string, string>(x.Key, x.Value.GetValue())).GetEnumerator()))
{
spanBuilder.AsChildOf(spanContext);
}
span = _tracer.Start(spanBuilder);
httpContext.SetSpan(span);
}
span?.Log(LogField.CreateNew().Event(@event));
}
public void BeginRequest([Property] HttpContext httpContext)
{
var patterns = _options.IgnoredRoutesRegexPatterns;
if (patterns == null || patterns.Any(x => Regex.IsMatch(httpContext.Request.Path, x)))
{
return;
}
var spanBuilder = new SpanBuilder($"server {httpContext.Request.Method} {httpContext.Request.Path}");
if (_tracer.Tracer.TryExtract(out var spanContext, httpContext.Request.Headers, (c, k) => c[k].GetValue(),
c => c.Select(x => new KeyValuePair <string, string>(x.Key, x.Value.GetValue())).GetEnumerator()))
{
spanBuilder.AsChildOf(spanContext);
}
var span = _tracer.Start(spanBuilder);
span.Log(LogField.CreateNew().ServerReceive());
span.Log(LogField.CreateNew().Event("AspNetCore BeginRequest"));
span.Tags
.Server().Component("AspNetCore")
.HttpMethod(httpContext.Request.Method)
.HttpUrl($"{httpContext.Request.Scheme}://{httpContext.Request.Host.ToUriComponent()}{httpContext.Request.Path}{httpContext.Request.QueryString}")
.HttpHost(httpContext.Request.Host.ToUriComponent())
.HttpPath(httpContext.Request.Path)
.HttpStatusCode(httpContext.Response.StatusCode)
.PeerAddress(httpContext.Connection.RemoteIpAddress.ToString())
.PeerPort(httpContext.Connection.RemotePort)
.UserIp(httpContext.GetUserIp());
_tracer.Tracer.SetEntrySpan(span);
}
public void BeginRequest([Property] HttpContext httpContext)
{
if (IgnoredRoute(httpContext.Request.Path))
{
return;
}
var carrier = _contextCarrierFactory.Create();
foreach (var item in carrier.Items)
{
item.HeadValue = httpContext.Request.Headers[item.HeadKey];
}
var httpRequestSpan = ContextManager.CreateEntrySpan($"{_skrTraceOptions.ApplicationCode} {httpContext.Request.Path}", carrier);
httpRequestSpan.AsHttp();
httpRequestSpan.SetComponent(SpanComponent.AspNetCore);
httpRequestSpan.Tags.Server()
.HttpMethod(httpContext.Request.Method)
.HttpUrl(httpContext.Request.GetDisplayUrl());
httpRequestSpan.Log(LogField.CreateNew().Event("AspNetCore Hosting BeginRequest")
.Message($"Request starting {httpContext.Request.Protocol} {httpContext.Request.Method} {httpContext.Request.GetDisplayUrl()}"));
}
public void BeforeOnException(ExceptionContext exceptionContext)
{
var httpContext = exceptionContext.HttpContext;
Event(httpContext, "Microsoft.AspNetCore.Mvc.BeforeOnException");
var span = httpContext.GetSpan();
span?.Log(LogField.CreateNew().EventError().ErrorKind(exceptionContext.Exception).ErrorObject(exceptionContext.Exception).Stack(exceptionContext.Exception.StackTrace));
}
public void DiagnosticUnhandledException([Property] HttpContext httpContext, [Property] Exception exception)
{
var span = _tracer.Tracer.GetEntrySpan();
if (span == null)
{
return;
}
span.Log(LogField.CreateNew().Event("AspNetCore UnhandledException"));
span.Exception(exception);
}
public void OnException(HttpContext httpContext, Exception exception, string @event)
{
var span = httpContext.GetSpan();
if (span == null)
{
return;
}
span.Log(LogField.CreateNew().Event(@event));
span.Exception(exception);
}
public void EndRequest([Property] HttpContext httpContext)
{
var span = _tracer.Tracer.GetEntrySpan();
if (span == null)
{
return;
}
span.Tags.HttpStatusCode(httpContext.Response.StatusCode);
span.Log(LogField.CreateNew().Event("AspNetCore EndRequest"));
span.Log(LogField.CreateNew().ServerSend());
span.Finish();
_tracer.Tracer.SetEntrySpan(null);
}
public static ISpan Exception(this ISpan span, Exception exception)
{
if (span == null)
{
return(span);
}
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
span.ErrorOccurred();
span.Log(LogField.CreateNew().EventError().ErrorKind(exception).Message(exception.Message).Stack(exception.StackTrace));
return(span);
}
public ISpan OnBeginRequest(HttpContext httpContext)
{
var spanBuilder = new SpanBuilder($"server {httpContext.Request.Method} {httpContext.Request.Path}");
if (_tracer.Tracer.TryExtract(out var spanContext, httpContext.Request.Headers, (c, k) => c[k],
c => c.Select(x => new KeyValuePair <string, string>(x.Key, x.Value)).GetEnumerator()))
{
spanBuilder.AsChildOf(spanContext);
}
var span = _tracer.Start(spanBuilder);
httpContext.SetSpan(span);
span.Log(LogField.CreateNew().ServerReceive());
span.Log(LogField.CreateNew().Event("Microsoft.AspNetCore.Hosting.BeginRequest"));
_tracer.Tracer.SetCurrentSpan(span);
return(span);
}
public async override Task Invoke(AspectContext context, AspectDelegate next)
{
var serviceType = context.ServiceMethod.DeclaringType;
if (excepts.Any(x => serviceType.Name.Matches(x)) || excepts.Any(x => serviceType.Namespace.Matches(x)) || context.Implementation is IServiceTracer)
{
await context.Invoke(next);
return;
}
await ServiceTracer?.ChildTraceAsync(context.ServiceMethod.GetReflector().DisplayName, DateTimeOffset.UtcNow, async span =>
{
span.Log(LogField.CreateNew().MethodExecuting());
span.Tags.Set("ServiceType", context.ServiceMethod.DeclaringType.GetReflector().FullDisplayName);
span.Tags.Set("ImplementationType", context.ImplementationMethod.DeclaringType.GetReflector().FullDisplayName);
await context.Invoke(next);
span.Log(LogField.CreateNew().MethodExecuted());
});
}
protected virtual async Task <HttpResponseMessage> TracingSendAsync(
OpenTracing.ISpan span,
HttpRequestMessage request,
CancellationToken cancellationToken,
Action <string> addTraceIdToRepo,
Func <HttpRequestMessage, CancellationToken, Task <HttpResponseMessage> > baseSendAsync)
{
if (request.Headers.Contains(PrefixSpanId))
{
request.Headers.Remove(PrefixSpanId);
request.Headers.TryAddWithoutValidation(PrefixSpanId, span.Context.SpanId);
}
addTraceIdToRepo(span.Context.TraceId);
span.SetTag(Tags.SpanKind, Tags.SpanKindClient)
.SetTag(Tags.HttpMethod, request.Method.Method)
.SetTag(Tags.HttpUrl, request.RequestUri.ToString())
//.SetTag(Tags.Host(request.RequestUri.Host)
//.HttpPath(request.RequestUri.PathAndQuery)
//.SetTag(Tags.PeerHostname(request.RequestUri.OriginalString)
.SetTag(Tags.PeerHostname, request.RequestUri.Host)
.SetTag(Tags.PeerPort, request.RequestUri.Port)
;
var dictionary = new Dictionary <string, string>();
_tracer.Inject(span.Context, BuiltinFormats.HttpHeaders, new TextMapInjectAdapter(dictionary));
foreach (var entry in dictionary)
{
request.Headers.Add(entry.Key, entry.Value);
}
span.Log(LogField.CreateNew().ClientSend());
var responseMessage = await baseSendAsync(request, cancellationToken);
span.Log(LogField.CreateNew().ClientReceive());
return(responseMessage);
}
protected virtual async Task <HttpResponseMessage> TracingSendAsync(ISpan span, HttpRequestMessage request, CancellationToken cancellationToken)
{
span.Tags.Client().Component("HttpClient")
.HttpMethod(request.Method.Method)
.HttpUrl(request.RequestUri.OriginalString)
.HttpHost(request.RequestUri.Host)
.HttpPath(request.RequestUri.PathAndQuery)
.PeerAddress(request.RequestUri.OriginalString)
.PeerHostName(request.RequestUri.Host)
.PeerPort(request.RequestUri.Port);
_tracer.Tracer.Inject(span.SpanContext, request.Headers, (c, k, v) => c.Add(k, v));
span.Log(LogField.CreateNew().ClientSend());
var responseMessage = await base.SendAsync(request, cancellationToken);
span.Log(LogField.CreateNew().ClientReceive());
return(responseMessage);
}
public void HttpResponse([Property(Name = "Response")] HttpResponseMessage response)
{
var span = _tracer.Tracer.GetExitSpan();
if (span == null)
{
return;
}
span.Log(LogField.CreateNew().ClientReceive());
span.Tags.HttpStatusCode((int)response.StatusCode);
var result = response.Content.ReadAsStringAsync().Result;
if (result.Length > 2048)
{
result = result.Substring(0, 2048) + "...";
}
span.Tags.Add("response", result);
span.Finish();
_tracer.Tracer.SetExitSpan(null);
}
public void OnEndRequest(HttpContext httpContext)
{
var span = httpContext.GetSpan();
if (span == null)
{
return;
}
span.Tags
.Server().Component("AspNetCore")
.HttpMethod(httpContext.Request.Method)
.HttpUrl($"{httpContext.Request.Scheme}://{httpContext.Request.Host.ToUriComponent()}{httpContext.Request.Path}{httpContext.Request.QueryString}")
.HttpHost(httpContext.Request.Host.ToUriComponent())
.HttpPath(httpContext.Request.Path)
.HttpStatusCode(httpContext.Response.StatusCode)
.PeerAddress(httpContext.Connection.RemoteIpAddress.ToString())
.PeerPort(httpContext.Connection.RemotePort);
span.Log(LogField.CreateNew().Event("Microsoft.AspNetCore.Hosting.EndRequest"));
span.Log(LogField.CreateNew().ServerSend());
span.Finish();
_tracer.Tracer.SetCurrentSpan(null);
}
public void EndRequest([Property] HttpContext httpContext)
{
var httpRequestSpan = ContextManager.ActiveSpan;
if (httpRequestSpan == null)
{
return;
}
var statusCode = httpContext.Response.StatusCode;
if (statusCode >= 400)
{
httpRequestSpan.ErrorOccurred();
}
httpRequestSpan.Tags.HttpStatusCode(statusCode);
httpRequestSpan.Log(LogField.CreateNew().Event("AspNetCore Hosting EndRequest")
.Message($"Request finished {httpContext.Response.StatusCode} {httpContext.Response.ContentType}"));
ContextManager.StopSpan(httpRequestSpan);
}
private void Event(HttpContext httpContext, string @event)
{
var span = httpContext.GetSpan();
span?.Log(LogField.CreateNew().Event(@event));
}
