internal static void DecorateWebServerSpan(
this ISpan span,
string resourceName,
string method,
string host,
string httpUrl,
WebTags tags,
IEnumerable <KeyValuePair <string, string> > tagsFromHeaders,
string remoteIp = null)
{
span.Type = SpanTypes.Web;
span.ResourceName = resourceName?.Trim();
if (tags is not null)
{
tags.HttpMethod = method;
tags.HttpRequestHeadersHost = host;
tags.HttpUrl = httpUrl;
tags.PeerIp = remoteIp;
}
foreach (KeyValuePair <string, string> kvp in tagsFromHeaders)
{
span.SetTag(kvp.Key, kvp.Value);
}
}
internal ApiTagProcessor(Cumulus cumulus, WebTags webtags)
{
this.cumulus = cumulus;
this.webtags = webtags;
tokenParser = new TokenParser();
tokenParser.OnToken += cumulus.TokenParserOnToken;
tokenParser.Encoding = new UTF8Encoding(false);
}
internal static void DecorateWebServerSpan(
this Span span,
string resourceName,
string method,
string host,
string httpUrl,
WebTags tags,
IEnumerable <KeyValuePair <string, string> > tagsFromHeaders)
{
span.Type = SpanTypes.Web;
span.ResourceName = resourceName?.Trim();
tags.SpanKind = SpanKinds.Server;
tags.HttpMethod = method;
tags.HttpRequestHeadersHost = host;
tags.HttpUrl = httpUrl;
tags.Language = TracerConstants.Language;
foreach (KeyValuePair <string, string> kvp in tagsFromHeaders)
{
span.SetTag(kvp.Key, kvp.Value);
}
}
private void OnBeginRequest(object sender, EventArgs eventArgs)
{
Scope scope = null;
try
{
var tracer = Tracer.Instance;
if (!tracer.Settings.IsIntegrationEnabled(IntegrationId))
{
// integration disabled
return;
}
var httpContext = (sender as HttpApplication)?.Context;
if (httpContext == null)
{
return;
}
HttpRequest httpRequest = httpContext.Request;
SpanContext propagatedContext = null;
var tagsFromHeaders = Enumerable.Empty <KeyValuePair <string, string> >();
var propagator = tracer.Propagator;
if (tracer.ActiveScope == null)
{
try
{
// extract propagated http headers
var headers = httpRequest.Headers.Wrap();
propagatedContext = propagator.Extract(headers);
tagsFromHeaders = headers.ExtractHeaderTags(tracer.Settings.HeaderTags);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
string host = httpRequest.Headers.Get("Host");
string httpMethod = httpRequest.HttpMethod.ToUpperInvariant();
string url = httpRequest.RawUrl.ToLowerInvariant();
var tags = new WebTags();
scope = tracer.StartActiveWithTags(_requestOperationName, propagatedContext, tags: tags);
// Leave resourceName blank for now - we'll update it in OnEndRequest
scope.Span.DecorateWebServerSpan(resourceName: null, httpMethod, host, url, tags, tagsFromHeaders);
tags.SetAnalyticsSampleRate(IntegrationId, tracer.Settings, enabledWithGlobalSetting: true);
httpContext.Items[_httpContextScopeKey] = scope;
// Decorate the incoming HTTP Request with distributed tracing headers
// in case the next processor cannot access the stored Scope
// (e.g. WCF being hosted in IIS)
propagator.Inject(scope.Span.Context, httpRequest.Headers.Wrap());
}
catch (Exception ex)
{
// Dispose here, as the scope won't be in context items and won't get disposed on request end in that case...
scope?.Dispose();
Log.Error(ex, "Datadog ASP.NET HttpModule instrumentation error");
}
}
internal static Scope CreateScope(object requestContext)
{
var requestMessage = requestContext.GetProperty <object>("RequestMessage").GetValueOrDefault();
if (requestMessage == null)
{
return(null);
}
var tracer = Tracer.Instance;
if (!tracer.Settings.IsIntegrationEnabled(IntegrationId))
{
// integration disabled, don't create a scope, skip this trace
return(null);
}
Scope scope = null;
try
{
SpanContext propagatedContext = null;
var tagsFromHeaders = Enumerable.Empty <KeyValuePair <string, string> >();
string host = null;
string httpMethod = null;
IDictionary <string, object> requestProperties = requestMessage.GetProperty <IDictionary <string, object> >("Properties").GetValueOrDefault();
if (requestProperties.TryGetValue("httpRequest", out object httpRequestProperty) &&
httpRequestProperty.GetType().FullName.Equals(HttpRequestMessagePropertyTypeName, StringComparison.OrdinalIgnoreCase))
{
var webHeaderCollection = httpRequestProperty.GetProperty <WebHeaderCollection>("Headers").GetValueOrDefault();
// we're using an http transport
host = webHeaderCollection[HttpRequestHeader.Host];
httpMethod = httpRequestProperty.GetProperty <string>("Method").GetValueOrDefault()?.ToUpperInvariant();
// try to extract propagated context values from http headers
if (tracer.ActiveScope == null)
{
try
{
var headers = webHeaderCollection.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 WebTags();
scope = tracer.StartActiveWithTags("wcf.request", propagatedContext, tags: tags);
var span = scope.Span;
object requestHeaders = requestMessage.GetProperty <object>("Headers").GetValueOrDefault();
string action = requestHeaders.GetProperty <string>("Action").GetValueOrDefault();
Uri requestHeadersTo = requestHeaders.GetProperty <Uri>("To").GetValueOrDefault();
span.DecorateWebServerSpan(
resourceName: action ?? requestHeadersTo?.LocalPath,
httpMethod,
host,
httpUrl: requestHeadersTo?.AbsoluteUri,
tags,
tagsFromHeaders);
tags.SetAnalyticsSampleRate(IntegrationId, tracer.Settings, enabledWithGlobalSetting: true);
}
catch (Exception ex)
{
Log.Error(ex, "Error creating or populating scope.");
}
// always returns the scope, even if it's null
return(scope);
}
internal void SetWebTags(WebTags webtags)
{
this.webtags = webtags;
}
private void OnBeginRequest(object sender, EventArgs eventArgs)
{
Scope scope = null;
try
{
var tracer = Tracer.Instance;
if (!tracer.Settings.IsIntegrationEnabled(IntegrationId))
{
// integration disabled
return;
}
var httpContext = (sender as HttpApplication)?.Context;
if (httpContext == null)
{
return;
}
// Make sure the request wasn't already handled by another TracingHttpModule,
// in case they're registered multiple times
if (httpContext.Items.Contains(_httpContextScopeKey))
{
return;
}
HttpRequest httpRequest = httpContext.Request;
SpanContext propagatedContext = null;
var tagsFromHeaders = Enumerable.Empty <KeyValuePair <string, string> >();
if (tracer.InternalActiveScope == null)
{
try
{
// extract propagated http headers
var headers = httpRequest.Headers.Wrap();
propagatedContext = SpanContextPropagator.Instance.Extract(headers);
tagsFromHeaders = SpanContextPropagator.Instance.ExtractHeaderTags(headers, tracer.Settings.HeaderTags, defaultTagPrefix: SpanContextPropagator.HttpRequestHeadersTagPrefix);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
string host = httpRequest.Headers.Get("Host");
string httpMethod = httpRequest.HttpMethod.ToUpperInvariant();
string url = httpRequest.RawUrl.ToLowerInvariant();
var tags = new WebTags();
scope = tracer.StartActiveInternal(_requestOperationName, propagatedContext, tags: tags);
// Leave resourceName blank for now - we'll update it in OnEndRequest
scope.Span.DecorateWebServerSpan(resourceName: null, httpMethod, host, url, tags, tagsFromHeaders);
tags.SetAnalyticsSampleRate(IntegrationId, tracer.Settings, enabledWithGlobalSetting: true);
// Decorate the incoming HTTP Request with distributed tracing headers
// in case the next processor cannot access the stored Scope
// (e.g. WCF being hosted in IIS)
if (HttpRuntime.UsingIntegratedPipeline)
{
SpanContextPropagator.Instance.Inject(scope.Span.Context, httpRequest.Headers.Wrap());
}
httpContext.Items[_httpContextScopeKey] = scope;
var security = Security.Instance;
if (security.Settings.Enabled)
{
security.InstrumentationGateway.RaiseRequestStart(httpContext, httpRequest, scope.Span, null);
}
tracer.TracerManager.Telemetry.IntegrationGeneratedSpan(IntegrationId);
}
catch (Exception ex)
{
// Dispose here, as the scope won't be in context items and won't get disposed on request end in that case...
scope?.Dispose();
Log.Error(ex, "Datadog ASP.NET HttpModule instrumentation error");
}
}
private void OnBeginRequest(object sender, EventArgs eventArgs)
{
Scope scope = null;
try
{
var tracer = Tracer.Instance;
if (!tracer.Settings.IsIntegrationEnabled(IntegrationName))
{
// integration disabled
return;
}
var httpContext = (sender as HttpApplication)?.Context;
if (httpContext == null)
{
return;
}
HttpRequest httpRequest = httpContext.Request;
SpanContext propagatedContext = null;
var tagsFromHeaders = Enumerable.Empty <KeyValuePair <string, string> >();
if (tracer.ActiveScope == null)
{
try
{
// extract propagated http headers
var headers = httpRequest.Headers.Wrap();
propagatedContext = SpanContextPropagator.Instance.Extract(headers);
tagsFromHeaders = SpanContextPropagator.Instance.ExtractHeaderTags(headers, tracer.Settings.HeaderTags);
}
catch (Exception ex)
{
Log.Error(ex, "Error extracting propagated HTTP headers.");
}
}
string host = httpRequest.Headers.Get("Host");
string httpMethod = httpRequest.HttpMethod.ToUpperInvariant();
string url = httpRequest.RawUrl.ToLowerInvariant();
string path = UriHelpers.GetRelativeUrl(httpRequest.Url, tryRemoveIds: true);
string resourceName = $"{httpMethod} {path.ToLowerInvariant()}";
var tags = new WebTags();
scope = tracer.StartActiveWithTags(_requestOperationName, propagatedContext, tags: tags);
scope.Span.DecorateWebServerSpan(resourceName, httpMethod, host, url, tags, tagsFromHeaders);
// set analytics sample rate if enabled
var analyticsSampleRate = tracer.Settings.GetIntegrationAnalyticsSampleRate(IntegrationName, enabledWithGlobalSetting: true);
if (analyticsSampleRate != null)
{
tags.AnalyticsSampleRate = analyticsSampleRate;
}
httpContext.Items[_httpContextScopeKey] = scope;
}
catch (Exception ex)
{
// Dispose here, as the scope won't be in context items and won't get disposed on request end in that case...
scope?.Dispose();
Log.Error(ex, "Datadog ASP.NET HttpModule instrumentation error");
}
}
