internal static void CaptureSpan(ISpan span, Action capturedAction)
{
try
{
capturedAction();
}
catch (Exception e) when(ExceptionFilter.Capture(e, span))
{
}
finally
{
span.End();
}
}
public void CaptureTransaction(string name, string type, Action <ITransaction> action, DistributedTracingData distributedTracingData = null)
{
var transaction = StartTransaction(name, type, distributedTracingData);
try
{
action(transaction);
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
transaction.End();
}
}
public void CaptureTransaction(string name, string type, Action action)
{
var transaction = StartTransaction(name, type);
try
{
action();
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
transaction.End();
}
}
public void CaptureSpan(string name, string type, Action capturedAction, string subType = null, string action = null)
{
var span = StartSpan(name, type, subType, action);
try
{
capturedAction();
}
catch (Exception e) when(ExceptionFilter.Capture(e, span))
{
}
finally
{
span.End();
}
}
public void CaptureTransaction(string name, string type, Action action, DistributedTracingData distributedTracingData = null, IEnumerable <SpanLink> links = null)
{
var transaction = StartTransaction(name, type, distributedTracingData, links: links);
try
{
action();
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
transaction.End();
}
}
public async Task InvokeAsync(HttpContext context)
{
var transaction = Agent.Tracer.StartTransaction($"{context.Request.Method} {context.Request.Path}",
Transaction.TYPE_REQUEST);
transaction.Context = new Context
{
Request = new Request
{
Method = context.Request.Method,
Socket = new Socket
{
Encrypted = context.Request.IsHttps,
Remote_address = context.Connection?.RemoteIpAddress?.ToString()
},
Url = new Url
{
Full = context.Request?.Path.Value,
HostName = context.Request.Host.Host,
Protocol = GetProtocolName(context.Request.Protocol),
Raw = context.Request?.Path.Value //TODO
},
HttpVersion = GetHttpVersion(context.Request.Protocol)
}
};
try
{
await next(context);
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
transaction.Result =
$"{GetProtocolName(context.Request.Protocol)} {context.Response.StatusCode.ToString()[0]}xx";
transaction.Context.Response = new Response
{
Finished = context.Response.HasStarted, //TODO ?
Status_code = context.Response.StatusCode
};
transaction.End();
}
}
public async Task InvokeAsync(HttpContext context)
{
var transaction = StartTransaction(context);
try
{
await _next(context);
}
catch (Exception e) when(transaction != null &&
ExceptionFilter.Capture(e, transaction, context, _configurationReader, _logger))
{
}
finally
{
StopTransaction(transaction, context);
}
}
internal static T CaptureSpan <T>(ISpan span, Func <T> func)
{
var retVal = default(T);
try
{
retVal = func();
}
catch (Exception e) when(ExceptionFilter.Capture(e, span))
{
}
finally
{
span.End();
}
return(retVal);
}
public T CaptureTransaction <T>(string name, string type, Func <T> func, DistributedTracingData distributedTracingData = null)
{
var transaction = StartTransaction(name, type, distributedTracingData);
var retVal = default(T);
try
{
retVal = func();
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
transaction.End();
}
return(retVal);
}
public T CaptureSpan <T>(string name, string type, Func <T> func, string subType = null, string action = null)
{
var span = StartSpan(name, type, subType, action);
var retVal = default(T);
try
{
retVal = func();
}
catch (Exception e) when(ExceptionFilter.Capture(e, span))
{
}
finally
{
span.End();
}
return(retVal);
}
public T CaptureTransaction <T>(string name, string type, Func <ITransaction, T> func)
{
var transaction = StartTransaction(name, type);
var retVal = default(T);
try
{
retVal = func(transaction);
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
transaction.End();
}
return(retVal);
}
/// <summary>
/// Registers a continuation on the task.
/// Within the continuation it ends the transaction and captures errors
/// </summary>
/// <param name="task">Task.</param>
/// <param name="transaction">Transaction.</param>
private void RegisterContinuation(Task task, ISpan span)
{
task.ContinueWith((t) =>
{
if (t.IsFaulted)
{
if (t.Exception != null)
{
if (t.Exception is AggregateException aggregateException)
{
ExceptionFilter.Capture(
aggregateException.InnerExceptions.Count == 1
? aggregateException.InnerExceptions[0]
: aggregateException.Flatten(), span);
}
else
{
ExceptionFilter.Capture(t.Exception, span);
}
}
else
{
span.CaptureError("Task faulted", "A task faulted", new StackTrace().GetFrames());
}
}
else if (t.IsCanceled)
{
if (t.Exception == null)
{
span.CaptureError("Task canceled", "A task was canceled", new StackTrace().GetFrames()); //TODO: this async stacktrace is hard to use, make it readable!
}
else
{
span.CaptureException(t.Exception);
}
}
span.End();
}, System.Threading.CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}
public async Task <T> CaptureTransaction <T>(string name, string type, Func <Task <T> > func, DistributedTracingData distributedTracingData = null, IEnumerable <SpanLink> links = null)
{
var transaction = StartTransaction(name, type, distributedTracingData, links: links);
try
{
return(await func());
}
catch (OperationCanceledException ex)
{
transaction.CaptureError("Task canceled", "A task was canceled", new StackTrace(ex).GetFrames());
throw;
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
transaction.End();
}
return(default);
public async Task InvokeAsync(HttpContext context)
{
var transaction = _tracer.StartTransactionInternal($"{context.Request.Method} {context.Request.Path}",
ApiConstants.TypeRequest);
var url = new Url
{
Full = context.Request?.Path.Value,
HostName = context.Request.Host.Host,
Protocol = GetProtocolName(context.Request.Protocol),
Raw = context.Request?.Path.Value //TODO
};
Dictionary <string, string> requestHeaders = null;
if (_configurationReader.CaptureHeaders)
{
requestHeaders = new Dictionary <string, string>();
foreach (var header in context.Request.Headers)
{
requestHeaders.Add(header.Key, header.Value.ToString());
}
}
transaction.Context.Request = new Request(context.Request.Method, url)
{
Socket = new Socket
{
Encrypted = context.Request.IsHttps,
RemoteAddress = context.Connection?.RemoteIpAddress?.ToString()
},
HttpVersion = GetHttpVersion(context.Request.Protocol),
Headers = requestHeaders
};
try
{
await _next(context);
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
Dictionary <string, string> responseHeaders = null;
if (_configurationReader.CaptureHeaders)
{
responseHeaders = new Dictionary <string, string>();
foreach (var header in context.Response.Headers)
{
responseHeaders.Add(header.Key, header.Value.ToString());
}
}
transaction.Result = $"{GetProtocolName(context.Request.Protocol)} {context.Response.StatusCode.ToString()[0]}xx";
transaction.Context.Response = new Response
{
Finished = context.Response.HasStarted, //TODO ?
StatusCode = context.Response.StatusCode,
Headers = responseHeaders
};
transaction.End();
}
}
public async Task InvokeAsync(HttpContext context)
{
Transaction transaction;
if (context.Request.Headers.ContainsKey(TraceParent.TraceParentHeaderName))
{
var headerValue = context.Request.Headers[TraceParent.TraceParentHeaderName].ToString();
var distributedTracingData = TraceParent.TryExtractTraceparent(headerValue);
if (distributedTracingData != null)
{
_logger.Debug()
?.Log(
"Incoming request with {TraceParentHeaderName} header. DistributedTracingData: {DistributedTracingData}. Continuing trace.",
TraceParent.TraceParentHeaderName, distributedTracingData);
transaction = _tracer.StartTransactionInternal(
$"{context.Request.Method} {context.Request.Path}",
ApiConstants.TypeRequest,
distributedTracingData);
}
else
{
_logger.Debug()
?.Log(
"Incoming request with invalid {TraceParentHeaderName} header (received value: {TraceParentHeaderValue}). Starting trace with new trace id.",
TraceParent.TraceParentHeaderName, headerValue);
transaction = _tracer.StartTransactionInternal($"{context.Request.Method} {context.Request.Path}",
ApiConstants.TypeRequest);
}
}
else
{
_logger.Debug()?.Log("Incoming request. Starting Trace.");
transaction = _tracer.StartTransactionInternal($"{context.Request.Method} {context.Request.Path}",
ApiConstants.TypeRequest);
}
if (transaction.IsSampled)
{
FillSampledTransactionContextRequest(context, transaction);
}
try
{
await _next(context);
}
catch (Exception e) when(ExceptionFilter.Capture(e, transaction))
{
}
finally
{
//fixup Transaction.Name - e.g. /user/profile/1 -> /user/profile/{id}
var routeData = (context.Features[typeof(IRoutingFeature)] as IRoutingFeature)?.RouteData;
if (routeData != null)
{
var name = GetNameFromRouteContext(routeData.Values);
if (!string.IsNullOrWhiteSpace(name))
{
transaction.Name = $"{context.Request.Method} {name}";
}
}
transaction.Result = Transaction.StatusCodeToResult(GetProtocolName(context.Request.Protocol), context.Response.StatusCode);
if (transaction.IsSampled)
{
FillSampledTransactionContextResponse(context, transaction);
FillSampledTransactionContextUser(context, transaction);
}
transaction.End();
}
}
