public void StartRemoteChildSpan_WithProbabilitySamplerDefaultSampler()
{
var configMock = Mock.Get <ITraceConfig>(traceConfig);
configMock.Setup((c) => c.ActiveTraceParams).Returns(TraceParams.Default);
// This traceId will not be sampled by the ProbabilitySampler because the first 8 bytes as long
// is not less than probability * Long.MAX_VALUE;
var traceId =
TraceId.FromBytes(
new byte[]
{
0x8F,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0,
0,
0,
0,
0,
0,
0,
0,
});
// If parent is sampled then the remote child must be sampled.
var childSpan =
SpanBuilder.Create(
SPAN_NAME,
SpanKind.Internal,
SpanContext.Create(
traceId,
SpanId.GenerateRandomId(randomHandler),
TraceOptions.Builder().SetIsSampled(true).Build(), Tracestate.Empty),
spanBuilderOptions)
.StartSpan();
Assert.True(childSpan.Context.IsValid);
Assert.Equal(traceId, childSpan.Context.TraceId);
Assert.True(childSpan.Context.TraceOptions.IsSampled);
childSpan.End();
Assert.Equal(TraceParams.Default, traceConfig.ActiveTraceParams);
// If parent is not sampled then the remote child must be not sampled.
childSpan =
SpanBuilder.Create(
SPAN_NAME,
SpanKind.Internal,
SpanContext.Create(
traceId,
SpanId.GenerateRandomId(randomHandler),
TraceOptions.Default, Tracestate.Empty),
spanBuilderOptions)
.StartSpan();
Assert.True(childSpan.Context.IsValid);
Assert.Equal(traceId, childSpan.Context.TraceId);
Assert.False(childSpan.Context.TraceOptions.IsSampled);
childSpan.End();
}
protected abstract void Inject(SpanContext spanContext, TCarrier carrier);
public void TestContextFromStringEmptyException()
{
Assert.Throws <ArgumentException>(() => SpanContext.ContextFromString(""));
}
/// <inheritdoc />
public bool ShouldSample(SpanContext parentContext, ActivityTraceId traceId, ActivitySpanId spanId, string name, IEnumerable <ILink> parentLinks)
{
return(true);
}
public void Inject <T>(SpanContext spanContext, T carrier, Action <T, string, string> setter)
{
Logger.Log($"LoggingTextFormat.Inject({spanContext}, ...)");
}
private static AspNetCoreMvcContext CreateContext(object actionDescriptor, object httpContext)
{
var context = new AspNetCoreMvcContext();
try
{
var request = httpContext.GetProperty("Request").GetValueOrDefault();
GetTagValues(
actionDescriptor,
request,
out string httpMethod,
out string host,
out string resourceName,
out string url,
out string controllerName,
out string actionName);
SpanContext propagatedContext = null;
var tracer = Tracer.Instance;
if (tracer.ActiveScope == null)
{
try
{
// extract propagated http headers
var requestHeaders = request.GetProperty <IEnumerable>("Headers").GetValueOrDefault();
if (requestHeaders != null)
{
var headersCollection = new DictionaryHeadersCollection();
foreach (object header in requestHeaders)
{
var key = header.GetProperty <string>("Key").GetValueOrDefault();
var values = header.GetProperty <IList <string> >("Value").GetValueOrDefault();
if (key != null && values != null)
{
headersCollection.Add(key, values);
}
}
propagatedContext = SpanContextPropagator.Instance.Extract(headersCollection);
}
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
var scope = tracer.StartActive(OperationName, propagatedContext);
context.Scope = scope;
var span = scope.Span;
span.DecorateWebServerSpan(
resourceName: resourceName,
method: httpMethod,
host: host,
httpUrl: url);
span.SetTag(Tags.AspNetController, controllerName);
span.SetTag(Tags.AspNetAction, actionName);
var analyticsSampleRate = tracer.Settings.GetIntegrationAnalyticsSampleRate(IntegrationName, enabledWithGlobalSetting: true);
span.SetMetric(Tags.Analytics, analyticsSampleRate);
}
catch (Exception ex)
{
context.ShouldInstrument = false;
context.Scope.Dispose();
Log.Error(
ex,
"An exception occurred when trying to initialize a Scope for {0}",
nameof(AspNetCoreMvc3Integration));
throw;
}
return(context);
}
private static GrpcReference BuildReference(SpanContext context, string referenceType)
{
return(JaegerGrpcSpanConverter.BuildReferences(new List <Reference> {
new Reference(context, referenceType)
}.AsReadOnly())[0]);
}
private static SyntaxList <RazorSyntaxNode> GetRewrittenMarkupStartTagChildren(MarkupStartTagSyntax node)
{
// Rewrites the children of the start tag to look like the legacy syntax tree.
if (node.IsMarkupTransition)
{
var tokens = node.DescendantNodes().Where(n => n is SyntaxToken token && !token.IsMissing).Cast <SyntaxToken>().ToArray();
var tokenBuilder = SyntaxListBuilder <SyntaxToken> .Create();
tokenBuilder.AddRange(tokens, 0, tokens.Length);
var markupTransition = SyntaxFactory.MarkupTransition(tokenBuilder.ToList()).Green.CreateRed(node, node.Position);
var spanContext = node.GetSpanContext();
if (spanContext != null)
{
markupTransition = markupTransition.WithSpanContext(spanContext);
}
var builder = new SyntaxListBuilder(1);
builder.Add(markupTransition);
return(new SyntaxList <RazorSyntaxNode>(builder.ToListNode().CreateRed(node, node.Position)));
}
SpanContext latestSpanContext = null;
var children = node.Children;
var newChildren = new SyntaxListBuilder(children.Count);
var literals = new List <MarkupTextLiteralSyntax>();
foreach (var child in children)
{
if (child is MarkupTextLiteralSyntax literal)
{
literals.Add(literal);
latestSpanContext = literal.GetSpanContext() ?? latestSpanContext;
}
else if (child is MarkupMiscAttributeContentSyntax miscContent)
{
foreach (var contentChild in miscContent.Children)
{
if (contentChild is MarkupTextLiteralSyntax contentLiteral)
{
literals.Add(contentLiteral);
latestSpanContext = contentLiteral.GetSpanContext() ?? latestSpanContext;
}
else
{
// Pop stack
AddLiteralIfExists();
newChildren.Add(contentChild);
}
}
}
else
{
AddLiteralIfExists();
newChildren.Add(child);
}
}
AddLiteralIfExists();
return(new SyntaxList <RazorSyntaxNode>(newChildren.ToListNode().CreateRed(node, node.Position)));
void AddLiteralIfExists()
{
if (literals.Count > 0)
{
var mergedLiteral = SyntaxUtilities.MergeTextLiterals(literals.ToArray());
mergedLiteral = mergedLiteral.WithSpanContext(latestSpanContext);
literals.Clear();
latestSpanContext = null;
newChildren.Add(mergedLiteral);
}
}
}
public void Propagate_SpanContextTracingEnabled()
{
TestSpanContextConversion(
SpanContext.Create(TRACE_ID, SPAN_ID, TraceOptions.Builder().SetIsSampled(true).Build()));
}
/// <summary>
/// Creates a scope used to instrument an MVC action and populates some common details.
/// </summary>
/// <param name="controllerContext">The System.Web.Mvc.ControllerContext that was passed as an argument to the instrumented method.</param>
/// <returns>A new scope used to instrument an MVC action.</returns>
internal static Scope CreateScope(ControllerContextStruct controllerContext)
{
Scope scope = null;
try
{
var httpContext = controllerContext.HttpContext;
if (httpContext == null)
{
return(null);
}
Span span = null;
// integration enabled, go create a scope!
var tracer = Tracer.Instance;
if (tracer.Settings.IsIntegrationEnabled(IntegrationId))
{
var newResourceNamesEnabled = tracer.Settings.RouteTemplateResourceNamesEnabled;
string host = httpContext.Request.Headers.Get("Host");
string httpMethod = httpContext.Request.HttpMethod.ToUpperInvariant();
string url = httpContext.Request.RawUrl.ToLowerInvariant();
string resourceName = null;
RouteData routeData = controllerContext.RouteData;
Route route = routeData?.Route as Route;
RouteValueDictionary routeValues = routeData?.Values;
bool wasAttributeRouted = false;
bool isChildAction = controllerContext.ParentActionViewContext.RouteData?.Values["controller"] is not null;
if (isChildAction && newResourceNamesEnabled)
{
// For child actions, we want to stick to what was requested in the http request.
// And the child action being a child, then we have already computed the resourcename.
resourceName = httpContext.Items[SharedItems.HttpContextPropagatedResourceNameKey] as string;
}
if (route == null && routeData?.Route.GetType().FullName == RouteCollectionRouteTypeName)
{
var routeMatches = routeValues?.GetValueOrDefault("MS_DirectRouteMatches") as List <RouteData>;
if (routeMatches?.Count > 0)
{
// route was defined using attribute routing i.e. [Route("/path/{id}")]
// get route and routeValues from the RouteData in routeMatches
wasAttributeRouted = true;
route = routeMatches[0].Route as Route;
routeValues = routeMatches[0].Values;
}
}
string routeUrl = route?.Url;
string areaName;
string controllerName;
string actionName;
if ((wasAttributeRouted || newResourceNamesEnabled) && string.IsNullOrEmpty(resourceName) && !string.IsNullOrEmpty(routeUrl))
{
resourceName = AspNetResourceNameHelper.CalculateResourceName(
httpMethod: httpMethod,
routeTemplate: routeUrl,
routeValues,
defaults: wasAttributeRouted ? null : route.Defaults,
out areaName,
out controllerName,
out actionName,
expandRouteTemplates: newResourceNamesEnabled && tracer.Settings.ExpandRouteTemplatesEnabled);
}
else
{
// just grab area/controller/action directly
areaName = (routeValues?.GetValueOrDefault("area") as string)?.ToLowerInvariant();
controllerName = (routeValues?.GetValueOrDefault("controller") as string)?.ToLowerInvariant();
actionName = (routeValues?.GetValueOrDefault("action") as string)?.ToLowerInvariant();
}
if (string.IsNullOrEmpty(resourceName) && httpContext.Request.Url != null)
{
var cleanUri = UriHelpers.GetCleanUriPath(httpContext.Request.Url);
resourceName = $"{httpMethod} {cleanUri.ToLowerInvariant()}";
}
if (string.IsNullOrEmpty(resourceName))
{
// Keep the legacy resource name, just to have something
resourceName = $"{httpMethod} {controllerName}.{actionName}";
}
SpanContext propagatedContext = null;
var tagsFromHeaders = Enumerable.Empty <KeyValuePair <string, string> >();
if (tracer.InternalActiveScope == null)
{
try
{
// extract propagated http headers
var headers = httpContext.Request.Headers.Wrap();
propagatedContext = SpanContextPropagator.Instance.Extract(headers);
tagsFromHeaders = SpanContextPropagator.Instance.ExtractHeaderTags(headers, tracer.Settings.HeaderTags, SpanContextPropagator.HttpRequestHeadersTagPrefix);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
var tags = new AspNetTags();
scope = tracer.StartActiveInternal(isChildAction ? ChildActionOperationName : OperationName, propagatedContext, tags: tags);
span = scope.Span;
span.DecorateWebServerSpan(
resourceName: resourceName,
method: httpMethod,
host: host,
httpUrl: url,
tags,
tagsFromHeaders);
tags.AspNetRoute = routeUrl;
tags.AspNetArea = areaName;
tags.AspNetController = controllerName;
tags.AspNetAction = actionName;
tags.SetAnalyticsSampleRate(IntegrationId, tracer.Settings, enabledWithGlobalSetting: true);
if (newResourceNamesEnabled && string.IsNullOrEmpty(httpContext.Items[SharedItems.HttpContextPropagatedResourceNameKey] as string))
{
// set the resource name in the HttpContext so TracingHttpModule can update root span
httpContext.Items[SharedItems.HttpContextPropagatedResourceNameKey] = resourceName;
}
tracer.TracerManager.Telemetry.IntegrationGeneratedSpan(IntegrationId);
}
}
catch (Exception ex)
{
Log.Error(ex, "Error creating or populating scope.");
}
return(scope);
}
/// <summary>
/// Creates a scope used to instrument an MVC action and populates some common details.
/// </summary>
/// <param name="controllerContext">The System.Web.Mvc.ControllerContext that was passed as an argument to the instrumented method.</param>
/// <returns>A new scope used to instrument an MVC action.</returns>
public static Scope CreateScope(object controllerContext)
{
Scope scope = null;
try
{
if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationName))
{
// integration disabled, don't create a scope, skip this trace
return(null);
}
if (controllerContext == null || controllerContext.GetType().FullName != ControllerContextTypeName)
{
return(null);
}
var httpContext = controllerContext.GetProperty <HttpContextBase>("HttpContext").GetValueOrDefault();
if (httpContext == null)
{
return(null);
}
string host = httpContext.Request.Headers.Get("Host");
string httpMethod = httpContext.Request.HttpMethod.ToUpperInvariant();
string url = httpContext.Request.RawUrl.ToLowerInvariant();
string resourceName = null;
RouteData routeData = controllerContext.GetProperty <RouteData>("RouteData").GetValueOrDefault();
Route route = routeData?.Route as Route;
RouteValueDictionary routeValues = routeData?.Values;
if (route == null && routeData?.Route.GetType().FullName == RouteCollectionRouteTypeName)
{
var routeMatches = routeValues?.GetValueOrDefault("MS_DirectRouteMatches") as List <RouteData>;
if (routeMatches?.Count > 0)
{
// route was defined using attribute routing i.e. [Route("/path/{id}")]
// get route and routeValues from the RouteData in routeMatches
route = routeMatches[0].Route as Route;
routeValues = routeMatches[0].Values;
if (route != null)
{
var resourceUrl = route.Url?.ToLowerInvariant() ?? string.Empty;
if (resourceUrl.FirstOrDefault() != '/')
{
resourceUrl = string.Concat("/", resourceUrl);
}
resourceName = $"{httpMethod} {resourceUrl}";
}
}
}
if (string.IsNullOrEmpty(resourceName) && httpContext.Request.Url != null)
{
var cleanUri = UriHelpers.GetRelativeUrl(httpContext.Request.Url, tryRemoveIds: true);
resourceName = $"{httpMethod} {cleanUri.ToLowerInvariant()}";
}
string controllerName = (routeValues?.GetValueOrDefault("controller") as string)?.ToLowerInvariant();
string actionName = (routeValues?.GetValueOrDefault("action") as string)?.ToLowerInvariant();
if (string.IsNullOrEmpty(resourceName))
{
// Keep the legacy resource name, just to have something
resourceName = $"{httpMethod} {controllerName}.{actionName}";
}
SpanContext propagatedContext = null;
var tracer = Tracer.Instance;
if (tracer.ActiveScope == null)
{
try
{
// extract propagated http headers
var headers = httpContext.Request.Headers.Wrap();
propagatedContext = tracer.Propagator.Extract(headers);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
scope = Tracer.Instance.StartActive(OperationName, propagatedContext);
Span span = scope.Span;
// Fail safe to catch templates in routing values
resourceName =
resourceName
.Replace("{controller}", controllerName)
.Replace("{action}", actionName);
IPAddress remoteIp = null;
if (Tracer.Instance.Settings.AddClientIpToServerSpans)
{
IPAddress.TryParse(httpContext.Request.UserHostAddress, out remoteIp);
}
span.DecorateWebServerSpan(
resourceName: resourceName,
method: httpMethod,
host: host,
httpUrl: url,
remoteIp: remoteIp);
span.SetTag(Tags.AspNetRoute, route?.Url);
span.SetTag(Tags.AspNetController, controllerName);
span.SetTag(Tags.AspNetAction, actionName);
// set analytics sample rate if enabled
var analyticsSampleRate = tracer.Settings.GetIntegrationAnalyticsSampleRate(IntegrationName, enabledWithGlobalSetting: true);
span.SetMetric(Tags.Analytics, analyticsSampleRate);
}
catch (Exception ex)
{
Log.Error(ex, "Error creating or populating scope.");
}
return(scope);
}
private void TestSpanContextConversion(SpanContext spanContext)
{
var propagatedBinarySpanContext = binaryFormat.FromByteArray(binaryFormat.ToByteArray(spanContext));
Assert.Equal(spanContext, propagatedBinarySpanContext);
}
/// <inheritdoc/>
public void Record(IEnumerable <IMeasurement> measurements, ITagContext tagContext, SpanContext spanContext)
{
}
/// <summary>
/// Creates a scope used to instrument an MVC action and populates some common details.
/// </summary>
/// <param name="controllerContext">The System.Web.Mvc.ControllerContext that was passed as an argument to the instrumented method.</param>
/// <returns>A new scope used to instrument an MVC action.</returns>
public static Scope CreateScope(ControllerContextStruct controllerContext)
{
Scope scope = null;
try
{
if (!Tracer.Instance.Settings.IsIntegrationEnabled(IntegrationId))
{
// integration disabled, don't create a scope, skip this trace
return(null);
}
var httpContext = controllerContext.HttpContext;
if (httpContext == null)
{
return(null);
}
var newResourceNamesEnabled = Tracer.Instance.Settings.RouteTemplateResourceNamesEnabled;
string host = httpContext.Request.Headers.Get("Host");
string httpMethod = httpContext.Request.HttpMethod.ToUpperInvariant();
string url = httpContext.Request.RawUrl.ToLowerInvariant();
string resourceName = null;
RouteData routeData = controllerContext.RouteData;
Route route = routeData?.Route as Route;
RouteValueDictionary routeValues = routeData?.Values;
bool wasAttributeRouted = false;
if (route == null && routeData?.Route.GetType().FullName == RouteCollectionRouteTypeName)
{
var routeMatches = routeValues?.GetValueOrDefault("MS_DirectRouteMatches") as List <RouteData>;
if (routeMatches?.Count > 0)
{
// route was defined using attribute routing i.e. [Route("/path/{id}")]
// get route and routeValues from the RouteData in routeMatches
wasAttributeRouted = true;
route = routeMatches[0].Route as Route;
routeValues = routeMatches[0].Values;
if (route != null)
{
var resourceUrl = route.Url?.ToLowerInvariant() ?? string.Empty;
if (resourceUrl.FirstOrDefault() != '/')
{
resourceUrl = string.Concat("/", resourceUrl);
}
resourceName = $"{httpMethod} {resourceUrl}";
}
}
}
string routeUrl = route?.Url;
string areaName = (routeValues?.GetValueOrDefault("area") as string)?.ToLowerInvariant();
string controllerName = (routeValues?.GetValueOrDefault("controller") as string)?.ToLowerInvariant();
string actionName = (routeValues?.GetValueOrDefault("action") as string)?.ToLowerInvariant();
if (newResourceNamesEnabled && string.IsNullOrEmpty(resourceName) && !string.IsNullOrEmpty(routeUrl))
{
resourceName = $"{httpMethod} /{routeUrl.ToLowerInvariant()}";
}
if (string.IsNullOrEmpty(resourceName) && httpContext.Request.Url != null)
{
var cleanUri = UriHelpers.GetCleanUriPath(httpContext.Request.Url);
resourceName = $"{httpMethod} {cleanUri.ToLowerInvariant()}";
}
if (string.IsNullOrEmpty(resourceName))
{
// Keep the legacy resource name, just to have something
resourceName = $"{httpMethod} {controllerName}.{actionName}";
}
// Replace well-known routing tokens
resourceName =
resourceName
.Replace("{area}", areaName)
.Replace("{controller}", controllerName)
.Replace("{action}", actionName);
if (newResourceNamesEnabled && !wasAttributeRouted && routeValues is not null && route is not null)
{
// Remove unused parameters from conventional route templates
// Don't bother with routes defined using attribute routing
foreach (var parameter in route.Defaults)
{
var parameterName = parameter.Key;
if (parameterName != "area" &&
parameterName != "controller" &&
parameterName != "action" &&
!routeValues.ContainsKey(parameterName))
{
resourceName = resourceName.Replace($"/{{{parameterName}}}", string.Empty);
}
}
}
SpanContext propagatedContext = null;
var tracer = Tracer.Instance;
var tagsFromHeaders = Enumerable.Empty <KeyValuePair <string, string> >();
if (tracer.ActiveScope == null)
{
try
{
// extract propagated http headers
var headers = httpContext.Request.Headers.Wrap();
propagatedContext = tracer.Propagator.Extract(headers);
tagsFromHeaders = headers.ExtractHeaderTags(tracer.Settings.HeaderTags, PropagationExtensions.HttpRequestHeadersTagPrefix);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
var tags = new AspNetTags();
scope = Tracer.Instance.StartActiveWithTags(OperationName, propagatedContext, tags: tags);
Span span = scope.Span;
span.DecorateWebServerSpan(
resourceName: resourceName,
method: httpMethod,
host: host,
httpUrl: url,
tags,
tagsFromHeaders);
tags.AspNetRoute = routeUrl;
tags.AspNetArea = areaName;
tags.AspNetController = controllerName;
tags.AspNetAction = actionName;
tags.SetAnalyticsSampleRate(IntegrationId, tracer.Settings, enabledWithGlobalSetting: true);
if (newResourceNamesEnabled)
{
// set the resource name in the HttpContext so TracingHttpModule can update root span
httpContext.Items[SharedConstants.HttpContextPropagatedResourceNameKey] = resourceName;
}
}
catch (Exception ex)
{
Log.Error(ex, "Error creating or populating scope.");
}
return(scope);
}
/// <summary>
/// Injects the specified <see cref="SpanContext"/> in the <see cref="HttpHeaders"/>.
/// </summary>
/// <param name="headers">The headers.</param>
/// <param name="context">The context.</param>
public static void Inject(this HttpHeaders headers, SpanContext context)
{
var wrapper = new HttpHeadersWrapper(headers);
wrapper.Inject(context);
}
public void Propagate_SpanContextNoTracing()
{
TestSpanContextConversion(SpanContext.Create(TRACE_ID, SPAN_ID, TraceOptions.DEFAULT));
}
internal static Span CreateTestSpan(bool setAttributes = true,
bool addEvents = true,
bool addLinks = true)
{
var startTimestamp = DateTime.UtcNow;
var endTimestamp = startTimestamp.AddSeconds(60);
var eventTimestamp = DateTime.UtcNow;
var traceId = ActivityTraceId.CreateFromString("e8ea7e9ac72de94e91fabc613f9686b2".AsSpan());
var parentSpanId = ActivitySpanId.CreateFromBytes(new byte[] { 12, 23, 34, 45, 56, 67, 78, 89 });
var attributes = new Dictionary <string, object>
{
{ "stringKey", "value" },
{ "longKey", 1L },
{ "longKey2", 1 },
{ "doubleKey", 1D },
{ "doubleKey2", 1F },
{ "boolKey", true },
};
var events = new List <IEvent>
{
Event.Create(
"Event1",
eventTimestamp,
new Dictionary <string, object>
{
{ "key", "value" },
}
),
Event.Create(
"Event2",
eventTimestamp,
new Dictionary <string, object>
{
{ "key", "value" },
}
),
};
var linkedSpanId = ActivitySpanId.CreateFromString("888915b6286b9c41".AsSpan());
var link = Link.FromSpanContext(SpanContext.Create(
traceId,
linkedSpanId,
ActivityTraceFlags.Recorded,
Tracestate.Empty));
var span = (Span)Tracing.Tracer
.SpanBuilder("Name")
.SetParent(SpanContext.Create(traceId, parentSpanId, ActivityTraceFlags.Recorded, Tracestate.Empty))
.SetSpanKind(SpanKind.Client)
.SetStartTimestamp(startTimestamp)
.StartSpan();
if (addLinks)
{
span.AddLink(link);
}
if (setAttributes)
{
foreach (var attribute in attributes)
{
span.SetAttribute(attribute);
}
}
if (addEvents)
{
foreach (var evnt in events)
{
span.AddEvent(evnt);
}
}
span.Status = Status.Ok;
span.End(endTimestamp);
return(span);
}
private static Scope CreateScope(RequestContext requestContext)
{
var requestMessage = requestContext?.RequestMessage;
if (requestMessage == null)
{
return(null);
}
var tracer = Tracer.Instance;
if (!tracer.Settings.IsIntegrationEnabled(IntegrationName))
{
// integration disabled, don't create a scope, skip this trace
return(null);
}
Scope scope = null;
try
{
SpanContext propagatedContext = null;
string host = null;
string httpMethod = null;
if (requestMessage.Properties.TryGetValue("httpRequest", out var httpRequestProperty) &&
httpRequestProperty is HttpRequestMessageProperty httpRequestMessageProperty)
{
// we're using an http transport
host = httpRequestMessageProperty.Headers[HttpRequestHeader.Host];
httpMethod = httpRequestMessageProperty.Method?.ToUpperInvariant();
// try to extract propagated context values from http headers
if (tracer.ActiveScope == null)
{
try
{
var headers = httpRequestMessageProperty.Headers.Wrap();
propagatedContext = SpanContextPropagator.Instance.Extract(headers);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
}
scope = tracer.StartActive("wcf.request", propagatedContext);
Span span = scope.Span;
span.DecorateWebServerSpan(
resourceName: requestMessage.Headers.Action,
httpMethod,
host,
httpUrl: requestMessage.Headers.To?.AbsoluteUri);
// set analytics sample rate if enabled
var analyticsSampleRate = tracer.Settings.GetIntegrationAnalyticsSampleRate(IntegrationName, enabledWithGlobalSetting: true);
span.SetMetric(Tags.Analytics, analyticsSampleRate);
}
catch (Exception ex)
{
Log.Error(ex, "Error creating or populating scope.");
}
// always returns the scope, even if it's null
return(scope);
}
protected override void Inject(SpanContext spanContext, ITextMap carrier)
{
throw new InvalidOperationException("Some Codecs can be faulty, this one is.");
}
/// <summary>
/// Injects the specified <see cref="SpanContext"/> in the <see cref="IHeaderCollection"/>.
/// </summary>
/// <param name="headers">The headers.</param>
/// <param name="context">The context.</param>
public static void Inject(this IHeaderCollection headers, SpanContext context)
{
headers.Set(HttpHeaderNames.HttpHeaderParentId, context.SpanId.ToString());
headers.Set(HttpHeaderNames.HttpHeaderTraceId, context.TraceId.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="AspNetCoreMvc2Integration"/> class.
/// </summary>
/// <param name="actionDescriptor">An ActionDescriptor with information about the current action.</param>
/// <param name="httpContext">The HttpContext for the current request.</param>
public AspNetCoreMvc2Integration(object actionDescriptor, object httpContext)
{
try
{
_httpContext = httpContext;
var request = _httpContext.GetProperty("Request").GetValueOrDefault();
GetTagValues(
actionDescriptor,
request,
out string httpMethod,
out string host,
out string resourceName,
out string url,
out string controllerName,
out string actionName);
SpanContext propagatedContext = null;
var tracer = Tracer.Instance;
if (tracer.ActiveScope == null)
{
try
{
// extract propagated http headers
var requestHeaders = request.GetProperty <IEnumerable>("Headers").GetValueOrDefault();
if (requestHeaders != null)
{
var headersCollection = new DictionaryHeadersCollection();
foreach (object header in requestHeaders)
{
var key = header.GetProperty <string>("Key").GetValueOrDefault();
var values = header.GetProperty <IList <string> >("Value").GetValueOrDefault();
if (key != null && values != null)
{
headersCollection.Add(key, values);
}
}
propagatedContext = SpanContextPropagator.Instance.Extract(headersCollection);
}
}
catch (Exception ex)
{
Log.ErrorException("Error extracting propagated HTTP headers.", ex);
}
}
_scope = tracer.StartActive(OperationName, propagatedContext);
var span = _scope.Span;
span.DecorateWebServerSpan(
resourceName: resourceName,
method: httpMethod,
host: host,
httpUrl: url);
span.SetTag(Tags.AspNetController, controllerName);
span.SetTag(Tags.AspNetAction, actionName);
// set analytics sample rate if enabled
var analyticsSampleRate = tracer.Settings.GetIntegrationAnalyticsSampleRate(IntegrationName, enabledWithGlobalSetting: true);
span.SetMetric(Tags.Analytics, analyticsSampleRate);
}
catch (Exception) when(DisposeObject(_scope))
{
// unreachable code
throw;
}
}
public LoggingSpanBuilder(string spanName, SpanKind spanKind, SpanContext remoteParentSpanContext)
: this(spanName, spanKind)
{
Logger.Log($"SpanBuilder.ctor({spanName}, {spanKind}, {remoteParentSpanContext})");
this.remoteParentSpanContext = remoteParentSpanContext;
}
/// <inheritdoc />
public Decision ShouldSample(SpanContext parentContext, ActivityTraceId traceId, ActivitySpanId spanId, string name, IEnumerable <Link> links)
{
return(new Decision(false));
}
public ISpanBuilder AddLink(SpanContext spanContext)
{
Logger.Log($"SpanBuilder.AddLink({spanContext})");
return(this);
}
private SyntaxList <RazorSyntaxNode> GetLegacyChildren()
{
// This method returns the children of this start tag in legacy format.
// This is needed to generate the same classified spans as the legacy syntax tree.
var builder = new SyntaxListBuilder(5);
var tokens = SyntaxListBuilder <SyntaxToken> .Create();
var context = this.GetSpanContext();
// We want to know if this tag contains non-whitespace attribute content to set the appropriate AcceptedCharacters.
// The prefix of a start tag(E.g '|<foo| attr>') will have 'Any' accepted characters if non-whitespace attribute content exists.
var acceptsAnyContext = new SpanContext(context.ChunkGenerator, SpanEditHandler.CreateDefault());
acceptsAnyContext.EditHandler.AcceptedCharacters = AcceptedCharactersInternal.Any;
var containsAttributesContent = false;
foreach (var attribute in Attributes)
{
if (!string.IsNullOrWhiteSpace(attribute.GetContent()))
{
containsAttributesContent = true;
break;
}
}
if (!OpenAngle.IsMissing)
{
tokens.Add(OpenAngle);
}
if (Bang != null)
{
builder.Add(SyntaxFactory.MarkupTextLiteral(tokens.Consume()).WithSpanContext(acceptsAnyContext));
tokens.Add(Bang);
var acceptsNoneContext = new SpanContext(context.ChunkGenerator, SpanEditHandler.CreateDefault());
acceptsNoneContext.EditHandler.AcceptedCharacters = AcceptedCharactersInternal.None;
builder.Add(SyntaxFactory.RazorMetaCode(tokens.Consume()).WithSpanContext(acceptsNoneContext));
}
if (!Name.IsMissing)
{
tokens.Add(Name);
}
builder.Add(SyntaxFactory.MarkupTextLiteral(tokens.Consume()).WithSpanContext(containsAttributesContent ? acceptsAnyContext : context));
builder.AddRange(Attributes);
if (ForwardSlash != null)
{
tokens.Add(ForwardSlash);
}
if (!CloseAngle.IsMissing)
{
tokens.Add(CloseAngle);
}
if (tokens.Count > 0)
{
builder.Add(SyntaxFactory.MarkupTextLiteral(tokens.Consume()).WithSpanContext(context));
}
return(new SyntaxList <RazorSyntaxNode>(builder.ToListNode().CreateRed(this, Position)));
}
public ISpanBuilder AddLink(SpanContext context, IDictionary <string, object> attributes)
{
Logger.Log($"SpanBuilder.AddLink({context}, {attributes.Count})");
return(this);
}
public void Inject(SpanContext spanContext, object carrier)
{
Inject(spanContext, (TCarrier)carrier);
}
public ISpanBuilder SetParent(SpanContext remoteParent)
{
Logger.Log($"SpanBuilder.SetParent({remoteParent})");
return(this);
}
public void TestContextFromStringMalformedException()
{
Assert.Throws <ArgumentException>(() => SpanContext.ContextFromString("ff:ff:ff"));
}
/// <inheritdoc />
public void Inject <TCarrier>(SpanContext context, IFormat <TCarrier> format, TCarrier carrier)
{
Propagators.ForEach(propagator =>
propagator.Inject(context, format, carrier)
);
}
