private Activity StartActivity(HttpContext httpContext)
{
var activity = new Activity(ActivityName);
if (httpContext.Request.Headers.TryGetValue(RequestIdHeaderName, out var requestId))
{
activity.SetParentId(requestId);
// We expect baggage to be empty by default
// Only very advanced users will be using it in near future, we encouradge them to keep baggage small (few items)
string[] baggage = httpContext.Request.Headers.GetCommaSeparatedValues(CorrelationContextHeaderName);
if (baggage != StringValues.Empty)
{
foreach (var item in baggage)
{
if (NameValueHeaderValue.TryParse(item, out var baggageItem))
{
activity.AddBaggage(baggageItem.Name.ToString(), baggageItem.Value.ToString());
}
}
}
}
if (_diagnosticListener.IsEnabled(ActivityStartKey))
{
_diagnosticListener.StartActivity(activity, new { HttpContext = httpContext });
}
else
{
activity.Start();
}
return(activity);
}
private void CheckValidTryParse(string input, NameValueHeaderValue expectedResult)
{
NameValueHeaderValue result = null;
Assert.True(NameValueHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
}
private void CheckInvalidTryParse(string input)
{
NameValueHeaderValue result = null;
Assert.False(NameValueHeaderValue.TryParse(input, out result));
Assert.Null(result);
}
private void CheckInvalidParse(string input)
{
Assert.Throws <FormatException>(() => { NameValueHeaderValue.Parse(input); });
Assert.False(NameValueHeaderValue.TryParse(input, out NameValueHeaderValue result));
Assert.Null(result);
}
public void TryParse_Invalid()
{
NameValueHeaderValue res;
Assert.IsFalse(NameValueHeaderValue.TryParse("", out res), "#1");
Assert.IsNull(res, "#2");
}
public void TryParse()
{
NameValueHeaderValue res;
Assert.IsTrue(NameValueHeaderValue.TryParse("a", out res), "#1");
Assert.AreEqual("a", res.Name, "#2");
Assert.IsNull(res.Value, "#3");
}
public void OnBeginRequest(HttpContext httpContext, long timestamp)
{
if (this.client.IsEnabled() && !IsAspNetCore20)
{
var activity = new Activity(ActivityCreatedByHostingDiagnosticListener);
var isActivityCreatedFromRequestIdHeader = false;
StringValues requestId;
StringValues standardRootId;
IHeaderDictionary requestHeaders = httpContext.Request.Headers;
if (requestHeaders.TryGetValue(RequestResponseHeaders.RequestIdHeader, out requestId))
{
requestId = StringUtilities.EnforceMaxLength(requestId, InjectionGuardConstants.RequestHeaderMaxLength);
isActivityCreatedFromRequestIdHeader = true;
activity.SetParentId(requestId);
string[] baggage = requestHeaders.GetCommaSeparatedValues(RequestResponseHeaders.CorrelationContextHeader);
if (baggage != StringValues.Empty)
{
foreach (var item in baggage)
{
NameValueHeaderValue baggageItem;
if (NameValueHeaderValue.TryParse(item, out baggageItem))
{
var itemName = StringUtilities.EnforceMaxLength(baggageItem.Name, InjectionGuardConstants.ContextHeaderKeyMaxLength);
var itemValue = StringUtilities.EnforceMaxLength(baggageItem.Value, InjectionGuardConstants.ContextHeaderValueMaxLength);
activity.AddBaggage(baggageItem.Name, baggageItem.Value);
}
}
}
}
else if (requestHeaders.TryGetValue(RequestResponseHeaders.StandardRootIdHeader, out standardRootId))
{
standardRootId = StringUtilities.EnforceMaxLength(standardRootId, InjectionGuardConstants.RequestHeaderMaxLength);
activity.SetParentId(standardRootId);
}
else
{
// As a first step in supporting W3C protocol in ApplicationInsights,
// we want to generate Activity Ids in the W3C compatible format.
// While .NET changes to Activity are pending, we want to ensure trace starts with W3C compatible Id
// as early as possible, so that everyone has a chance to upgrade and have compatibility with W3C systems once they arrive.
// So if there is no current Activity (i.e. there were no Request-Id header in the incoming request), we'll override ParentId on
// the current Activity by the properly formatted one. This workaround should go away
// with W3C support on .NET https://github.com/dotnet/corefx/issues/30331
activity.SetParentId(StringUtilities.GenerateTraceId());
// end of workaround
}
activity.Start();
httpContext.Features.Set(activity);
var requestTelemetry = InitializeRequestTelemetry(httpContext, activity, isActivityCreatedFromRequestIdHeader, timestamp);
SetAppIdInResponseHeader(httpContext, requestTelemetry);
}
}
private Activity StartActivity(HttpContext httpContext, out bool hasDiagnosticListener)
{
var activity = new Activity(ActivityName);
hasDiagnosticListener = false;
var headers = httpContext.Request.Headers;
if (!headers.TryGetValue(HeaderNames.TraceParent, out var requestId))
{
headers.TryGetValue(HeaderNames.RequestId, out requestId);
}
if (!StringValues.IsNullOrEmpty(requestId))
{
activity.SetParentId(requestId);
if (headers.TryGetValue(HeaderNames.TraceState, out var traceState))
{
activity.TraceStateString = traceState;
}
// We expect baggage to be empty by default
// Only very advanced users will be using it in near future, we encourage them to keep baggage small (few items)
var baggage = headers.GetCommaSeparatedValues(HeaderNames.Baggage);
if (baggage.Length == 0)
{
baggage = headers.GetCommaSeparatedValues(HeaderNames.CorrelationContext);
}
// AddBaggage adds items at the beginning of the list, so we need to add them in reverse to keep the same order as the client
// An order could be important if baggage has two items with the same key (that is allowed by the contract)
for (var i = baggage.Length - 1; i >= 0; i--)
{
if (NameValueHeaderValue.TryParse(baggage[i], out var baggageItem))
{
activity.AddBaggage(baggageItem.Name.ToString(), HttpUtility.UrlDecode(baggageItem.Value.ToString()));
}
}
}
_diagnosticListener.OnActivityImport(activity, httpContext);
if (_diagnosticListener.IsEnabled(ActivityStartKey))
{
hasDiagnosticListener = true;
StartActivity(activity, httpContext);
}
else
{
activity.Start();
}
return(activity);
}
private Activity?StartActivity(IIncomingPhysicalMessageContext context)
{
if (!context.MessageHeaders.TryGetValue(Headers.TraceParentHeaderName, out var parentId))
{
context.MessageHeaders.TryGetValue(Headers.RequestIdHeaderName, out parentId);
}
string?traceStateString = default;
List <KeyValuePair <string, string?> > baggageItems = new();
if (!string.IsNullOrEmpty(parentId))
{
if (context.MessageHeaders.TryGetValue(Headers.TraceStateHeaderName, out var traceState))
{
traceStateString = traceState;
}
if (context.MessageHeaders.TryGetValue(Headers.BaggageHeaderName, out var baggageValue) ||
context.MessageHeaders.TryGetValue(Headers.CorrelationContextHeaderName, out baggageValue))
{
var baggage = baggageValue.Split(',');
if (baggage.Length > 0)
{
foreach (var item in baggage)
{
if (NameValueHeaderValue.TryParse(item, out var baggageItem))
{
baggageItems.Add(new KeyValuePair <string, string?>(baggageItem.Name, HttpUtility.UrlDecode(baggageItem.Value)));
}
}
}
}
}
var activity = parentId == null
? NServiceBusActivitySource.ActivitySource.StartActivity(ActivityNames.IncomingPhysicalMessage, ActivityKind.Consumer)
: NServiceBusActivitySource.ActivitySource.StartActivity(ActivityNames.IncomingPhysicalMessage, ActivityKind.Consumer, parentId);
if (activity == null)
{
return(activity);
}
activity.TraceStateString = traceStateString;
_activityEnricher.Enrich(activity, context);
foreach (var baggageItem in baggageItems)
{
activity.AddBaggage(baggageItem.Key, baggageItem.Value);
}
return(activity);
}
private Activity StartActivity(HttpContext httpContext, out bool hasDiagnosticListener)
{
var activity = new Activity(ActivityName);
hasDiagnosticListener = false;
var headers = httpContext.Request.Headers;
if (!headers.TryGetValue(HeaderNames.TraceParent, out var requestId))
{
headers.TryGetValue(HeaderNames.RequestId, out requestId);
}
if (!StringValues.IsNullOrEmpty(requestId))
{
activity.SetParentId(requestId);
if (headers.TryGetValue(HeaderNames.TraceState, out var traceState))
{
activity.TraceStateString = traceState;
}
// We expect baggage to be empty by default
// Only very advanced users will be using it in near future, we encourage them to keep baggage small (few items)
string[] baggage = headers.GetCommaSeparatedValues(HeaderNames.CorrelationContext);
if (baggage.Length > 0)
{
foreach (var item in baggage)
{
if (NameValueHeaderValue.TryParse(item, out var baggageItem))
{
activity.AddBaggage(baggageItem.Name.ToString(), HttpUtility.UrlDecode(baggageItem.Value.ToString()));
}
}
}
}
_diagnosticListener.OnActivityImport(activity, httpContext);
if (_diagnosticListener.IsEnabled(ActivityStartKey))
{
hasDiagnosticListener = true;
StartActivity(activity, httpContext);
}
else
{
activity.Start();
}
return(activity);
}
private void ReadCorrelationContext(IHeaderDictionary requestHeaders, Activity activity)
{
string[] baggage = requestHeaders.GetCommaSeparatedValues(RequestResponseHeaders.CorrelationContextHeader);
if (baggage != StringValues.Empty && !activity.Baggage.Any())
{
foreach (var item in baggage)
{
if (NameValueHeaderValue.TryParse(item, out var baggageItem))
{
var itemName = StringUtilities.EnforceMaxLength(baggageItem.Name, InjectionGuardConstants.ContextHeaderKeyMaxLength);
var itemValue = StringUtilities.EnforceMaxLength(baggageItem.Value, InjectionGuardConstants.ContextHeaderValueMaxLength);
activity.AddBaggage(itemName, itemValue);
}
}
}
}
private static Activity StartActivity(IncomingStepContext context)
{
var activity = new Activity(Constants.ConsumerActivityName);
var headers = context.Load <TransportMessage>().Headers;
if (!headers.TryGetValue(Constants.TraceParentHeaderName, out var requestId))
{
headers.TryGetValue(Constants.RequestIdHeaderName, out requestId);
}
if (!string.IsNullOrEmpty(requestId))
{
activity.SetParentId(requestId);
if (headers.TryGetValue(Constants.TraceStateHeaderName, out var traceState))
{
activity.TraceStateString = traceState;
}
if (headers.TryGetValue(Constants.CorrelationContextHeaderName, out var correlationContext))
{
var baggage = correlationContext.Split(',');
if (baggage.Length > 0)
{
foreach (var item in baggage)
{
if (NameValueHeaderValue.TryParse(item, out var baggageItem))
{
activity.AddBaggage(baggageItem.Name, HttpUtility.UrlDecode(baggageItem.Value));
}
}
}
}
}
DiagnosticListener.OnActivityImport(activity, context);
activity.Start();
if (DiagnosticListener.IsEnabled(BeforeProcessMessage.EventName, context))
{
DiagnosticListener.Write(BeforeProcessMessage.EventName, new BeforeProcessMessage(context, activity));
}
return(activity);
}
private void CheckValidParse(string input, NameValueHeaderValue expectedResult)
{
NameValueHeaderValue result = NameValueHeaderValue.Parse(input);
Assert.Equal(expectedResult, result);
Assert.True(NameValueHeaderValue.TryParse(input, out result));
Assert.Equal(expectedResult, result);
// New lines are never allowed
for (int i = 0; i < input.Length; i++)
{
CheckInvalidParse(input.Insert(i, "\r"));
CheckInvalidParse(input.Insert(i, "\n"));
CheckInvalidParse(input.Insert(i, "\r\n"));
CheckInvalidParse(input.Insert(i, "\r\n "));
}
}
public void OnBeginRequest(HttpContext httpContext, long timestamp)
{
if (this.client.IsEnabled() && !IsAspNetCore20)
{
var activity = new Activity(ActivityCreatedByHostingDiagnosticListener);
var isActivityCreatedFromRequestIdHeader = false;
StringValues requestId;
StringValues standardRootId;
IHeaderDictionary requestHeaders = httpContext.Request.Headers;
if (requestHeaders.TryGetValue(RequestResponseHeaders.RequestIdHeader, out requestId))
{
requestId = StringUtilities.EnforceMaxLength(requestId, InjectionGuardConstants.RequestHeaderMaxLength);
isActivityCreatedFromRequestIdHeader = true;
activity.SetParentId(requestId);
string[] baggage = requestHeaders.GetCommaSeparatedValues(RequestResponseHeaders.CorrelationContextHeader);
if (baggage != StringValues.Empty)
{
foreach (var item in baggage)
{
NameValueHeaderValue baggageItem;
if (NameValueHeaderValue.TryParse(item, out baggageItem))
{
var itemName = StringUtilities.EnforceMaxLength(baggageItem.Name, InjectionGuardConstants.ContextHeaderKeyMaxLength);
var itemValue = StringUtilities.EnforceMaxLength(baggageItem.Value, InjectionGuardConstants.ContextHeaderValueMaxLength);
activity.AddBaggage(baggageItem.Name, baggageItem.Value);
}
}
}
}
else if (requestHeaders.TryGetValue(RequestResponseHeaders.StandardRootIdHeader, out standardRootId))
{
standardRootId = StringUtilities.EnforceMaxLength(standardRootId, InjectionGuardConstants.RequestHeaderMaxLength);
activity.SetParentId(standardRootId);
}
activity.Start();
httpContext.Features.Set(activity);
var requestTelemetry = InitializeRequestTelemetryFromActivity(httpContext, activity, isActivityCreatedFromRequestIdHeader, timestamp);
SetAppIdInResponseHeader(httpContext, requestTelemetry);
}
}
private void CheckInvalidTryParse(string?input)
{
Assert.False(NameValueHeaderValue.TryParse(input, out var result));
Assert.Null(result);
}