//// netcoreapp1.1 and prior event. See https://github.com/dotnet/corefx/blob/release/1.0.0-rc2/src/Common/src/System/Net/Http/HttpHandlerDiagnosticListenerExtensions.cs.
/// <summary>
/// Diagnostic event handler method for 'System.Net.Http.Request' event.
/// </summary>
internal void OnRequest(HttpRequestMessage request, Guid loggingRequestId)
{
if (request != null && request.RequestUri != null &&
!this.applicationInsightsUrlFilter.IsApplicationInsightsUrl(request.RequestUri))
{
DependencyCollectorEventSource.Log.HttpCoreDiagnosticSourceListenerRequest(loggingRequestId);
Uri requestUri = request.RequestUri;
var resourceName = request.Method.Method + " " + requestUri.AbsolutePath;
var dependency = this.client.StartOperation <DependencyTelemetry>(resourceName);
// TODO[tracestate]: remove, this is done in base SDK
var tracestate = Activity.Current?.TraceStateString;
if (!string.IsNullOrEmpty(tracestate) && !dependency.Telemetry.Properties.ContainsKey(W3CConstants.TracestatePropertyKey))
{
dependency.Telemetry.Properties.Add(W3CConstants.TracestatePropertyKey, tracestate);
}
dependency.Telemetry.Target = DependencyTargetNameHelper.GetDependencyTargetName(requestUri);
dependency.Telemetry.Type = RemoteDependencyConstants.HTTP;
dependency.Telemetry.Data = requestUri.OriginalString;
dependency.Telemetry.SetOperationDetail(RemoteDependencyConstants.HttpRequestOperationDetailName, request);
this.PendingDependencyTelemetry.AddIfNotExists(request, dependency);
this.InjectRequestHeaders(request, dependency.Telemetry.Context.InstrumentationKey);
}
}
/// <summary>
/// On begin callback from Framework event source.
/// </summary>
/// <param name="id">This object.</param>
/// <param name="resourceName">URI of the web request.</param>
public void OnBeginHttpCallback(long id, string resourceName)
{
try
{
DependencyCollectorEventSource.Log.BeginCallbackCalled(id, resourceName);
if (string.IsNullOrEmpty(resourceName))
{
DependencyCollectorEventSource.Log.NotExpectedCallback(id, "OnBeginHttp", "resourceName is empty");
return;
}
if (this.applicationInsightsUrlFilter.IsApplicationInsightsUrl(resourceName))
{
return;
}
Uri url;
try
{
url = new Uri(resourceName);
}
catch (UriFormatException)
{
DependencyCollectorEventSource.Log.NotExpectedCallback(id, "OnBeginHttp", "resourceName is not a URL " + resourceName);
return;
}
var telemetryTuple = this.TelemetryTable.Get(id);
if (telemetryTuple != null)
{
// this operation is already being tracked. We will not restart operation
if (telemetryTuple.Item1 != null)
{
DependencyCollectorEventSource.Log.TrackingAnExistingTelemetryItemVerbose();
return;
}
}
bool isCustomCreated = false;
var telemetry = ClientServerDependencyTracker.BeginTracking(this.telemetryClient);
telemetry.Type = RemoteDependencyConstants.HTTP;
telemetry.Name = url.AbsolutePath;
telemetry.Target = DependencyTargetNameHelper.GetDependencyTargetName(url);
telemetry.Data = url.OriginalString;
this.TelemetryTable.Store(id, new Tuple <DependencyTelemetry, bool>(telemetry, isCustomCreated));
}
catch (Exception exception)
{
DependencyCollectorEventSource.Log.CallbackError(id, "OnBeginHttp", exception);
}
}
public void DependencyTargetNameHelperTests()
{
Uri httpPortDefaultUri = new Uri("http://www.microsoft.com");
Uri httpsPortDefaultUri = new Uri("https://www.microsoft.com");
Uri httpPortExplicitUri = new Uri("http://www.microsoft.com:80");
Uri httpsPortExplicitUri = new Uri("http://www.microsoft.com:443");
Uri randomPortExplicitUri = new Uri("http://www.microsoft.com:1010");
Assert.AreEqual(httpPortDefaultUri.Host, DependencyTargetNameHelper.GetDependencyTargetName(httpPortDefaultUri));
Assert.AreEqual(httpsPortDefaultUri.Host, DependencyTargetNameHelper.GetDependencyTargetName(httpsPortDefaultUri));
Assert.AreEqual(httpPortExplicitUri.Host, DependencyTargetNameHelper.GetDependencyTargetName(httpPortExplicitUri));
Assert.AreEqual(httpsPortExplicitUri.Host, DependencyTargetNameHelper.GetDependencyTargetName(httpsPortExplicitUri));
Assert.AreEqual(randomPortExplicitUri.Host + ":" + randomPortExplicitUri.Port, DependencyTargetNameHelper.GetDependencyTargetName(randomPortExplicitUri));
}
private static void SetHttpProperties(Activity activity, DependencyTelemetry dependency)
{
string method = null;
string url = null;
string status = null;
foreach (var tag in activity.Tags)
{
if (tag.Key == "http.url")
{
url = tag.Value;
}
else if (tag.Key == "http.method")
{
method = tag.Value;
}
else if (tag.Key == "requestId")
{
dependency.Properties["ClientRequestId"] = tag.Value;
}
else if (tag.Key == "serviceRequestId")
{
dependency.Properties["ServerRequestId"] = tag.Value;
}
else if (tag.Key == "http.status_code")
{
status = tag.Value;
}
}
// TODO: could be optimized to avoid full URI parsing and allocation
if (url == null || !Uri.TryCreate(url, UriKind.Absolute, out var parsedUrl))
{
DependencyCollectorEventSource.Log.FailedToParseUrl(url);
return;
}
dependency.Name = string.Concat(method, " ", parsedUrl.AbsolutePath);
dependency.Data = url;
dependency.Target = DependencyTargetNameHelper.GetDependencyTargetName(parsedUrl);
dependency.ResultCode = status;
if (int.TryParse(status, out var statusCode))
{
dependency.Success = (statusCode > 0) && (statusCode < 400);
}
}
//// netcoreapp1.1 and prior event. See https://github.com/dotnet/corefx/blob/release/1.0.0-rc2/src/Common/src/System/Net/Http/HttpHandlerDiagnosticListenerExtensions.cs.
/// <summary>
/// Diagnostic event handler method for 'System.Net.Http.Request' event.
/// </summary>
internal void OnRequest(HttpRequestMessage request, Guid loggingRequestId)
{
if (request != null && request.RequestUri != null &&
!this.applicationInsightsUrlFilter.IsApplicationInsightsUrl(request.RequestUri))
{
DependencyCollectorEventSource.Log.HttpCoreDiagnosticSourceListenerRequest(loggingRequestId);
Uri requestUri = request.RequestUri;
var resourceName = request.Method.Method + " " + requestUri.AbsolutePath;
var dependency = this.client.StartOperation <DependencyTelemetry>(resourceName);
dependency.Telemetry.Target = DependencyTargetNameHelper.GetDependencyTargetName(requestUri);
dependency.Telemetry.Type = RemoteDependencyConstants.HTTP;
dependency.Telemetry.Data = requestUri.OriginalString;
dependency.Telemetry.SetOperationDetail(RemoteDependencyConstants.HttpRequestOperationDetailName, request);
this.PendingDependencyTelemetry.AddIfNotExists(request, dependency);
this.InjectRequestHeaders(request, dependency.Telemetry.Context.InstrumentationKey);
}
}
/// <summary>
/// Common helper for all Begin Callbacks.
/// </summary>
/// <param name="thisObj">This object.</param>
/// <param name="isAsyncCall">Indicates if the method used is async or not.</param>
/// <returns>Null object as all context is maintained in this class via weak tables.</returns>
private object OnBegin(object thisObj, bool isAsyncCall)
{
try
{
if (thisObj == null)
{
DependencyCollectorEventSource.Log.NotExpectedCallback(0, "OnBeginHttp", "thisObj == null");
return(null);
}
WebRequest webRequest = thisObj as WebRequest;
if (webRequest == null)
{
DependencyCollectorEventSource.Log.UnexpectedCallbackParameter("WebRequest");
}
var url = this.GetUrl(webRequest);
if (url == null)
{
DependencyCollectorEventSource.Log.NotExpectedCallback(thisObj.GetHashCode(), "OnBeginHttp", "resourceName is empty");
return(null);
}
string httMethod = webRequest.Method;
string resourceName = url.AbsolutePath;
if (!string.IsNullOrEmpty(httMethod))
{
resourceName = httMethod + " " + resourceName;
}
DependencyCollectorEventSource.Log.BeginCallbackCalled(thisObj.GetHashCode(), resourceName);
if (this.applicationInsightsUrlFilter.IsApplicationInsightsUrl(url.ToString()))
{
// Not logging as we will be logging for all outbound AI calls
return(null);
}
// If the object already exists, don't add again. This happens because either GetResponse or GetRequestStream could
// be the starting point for the outbound call.
var telemetryTuple = this.TelemetryTable.Get(thisObj);
if (telemetryTuple != null)
{
if (telemetryTuple.Item1 != null)
{
DependencyCollectorEventSource.Log.TrackingAnExistingTelemetryItemVerbose();
return(null);
}
}
bool isCustomCreated = false;
var telemetry = ClientServerDependencyTracker.BeginTracking(this.telemetryClient);
telemetry.Name = resourceName;
telemetry.Target = DependencyTargetNameHelper.GetDependencyTargetName(url);
telemetry.Type = RemoteDependencyConstants.HTTP;
telemetry.Data = url.OriginalString;
this.TelemetryTable.Store(thisObj, new Tuple <DependencyTelemetry, bool>(telemetry, isCustomCreated));
if (string.IsNullOrEmpty(telemetry.Context.InstrumentationKey))
{
// Instrumentation key is probably empty, because the context has not yet had a chance to associate the requestTelemetry to the telemetry client yet.
// and get they instrumentation key from all possible sources in the process. Let's do that now.
this.telemetryClient.Initialize(telemetry);
}
// Add the source instrumentation key header if collection is enabled, the request host is not in the excluded list and the same header doesn't already exist
if (this.setCorrelationHeaders &&
!this.correlationDomainExclusionList.Contains(url.Host))
{
if (!string.IsNullOrEmpty(telemetry.Context.InstrumentationKey) &&
webRequest.Headers[RequestResponseHeaders.SourceInstrumentationKeyHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.SourceInstrumentationKeyHeader, InstrumentationKeyHashLookupHelper.GetInstrumentationKeyHash(telemetry.Context.InstrumentationKey));
}
// Add the root ID
var rootId = telemetry.Context.Operation.Id;
if (!string.IsNullOrEmpty(rootId) && webRequest.Headers[RequestResponseHeaders.StandardRootIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.StandardRootIdHeader, rootId);
}
// Add the parent ID
var parentId = telemetry.Id;
if (!string.IsNullOrEmpty(parentId) && webRequest.Headers[RequestResponseHeaders.StandardParentIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.StandardParentIdHeader, parentId);
}
}
}
catch (Exception exception)
{
DependencyCollectorEventSource.Log.CallbackError(thisObj == null ? 0 : thisObj.GetHashCode(), "OnBeginHttp", exception);
}
return(null);
}
/// <summary>
/// Common helper for all Begin Callbacks.
/// </summary>
/// <param name="thisObj">This object.</param>
/// <param name="injectCorrelationHeaders">Flag that enables Request-Id and Correlation-Context headers injection.
/// Should be set to true only for profiler and old versions of DiagnosticSource Http hook events.</param>
/// <returns>Null object as all context is maintained in this class via weak tables.</returns>
internal object OnBegin(object thisObj, bool injectCorrelationHeaders = true)
{
try
{
if (thisObj == null)
{
DependencyCollectorEventSource.Log.NotExpectedCallback(0, "OnBeginHttp", "thisObj == null");
return(null);
}
WebRequest webRequest = thisObj as WebRequest;
if (webRequest == null)
{
DependencyCollectorEventSource.Log.UnexpectedCallbackParameter("WebRequest");
}
var url = GetUrl(webRequest);
if (url == null)
{
DependencyCollectorEventSource.Log.NotExpectedCallback(thisObj.GetHashCode(), "OnBeginHttp",
"resourceName is empty");
return(null);
}
string httpMethod = webRequest.Method;
string resourceName = url.AbsolutePath;
if (!string.IsNullOrEmpty(httpMethod))
{
resourceName = httpMethod + " " + resourceName;
}
DependencyCollectorEventSource.Log.BeginCallbackCalled(thisObj.GetHashCode(), resourceName);
if (this.applicationInsightsUrlFilter.IsApplicationInsightsUrl(url))
{
// Not logging as we will be logging for all outbound AI calls
return(null);
}
if (webRequest.Headers[W3C.W3CConstants.TraceParentHeader] != null && Activity.DefaultIdFormat == ActivityIdFormat.W3C)
{
DependencyCollectorEventSource.Log.HttpRequestAlreadyInstrumented();
return(null);
}
// If the object already exists, don't add again. This happens because either GetResponse or GetRequestStream could
// be the starting point for the outbound call.
DependencyTelemetry telemetry = null;
var telemetryTuple = this.GetTupleForWebDependencies(webRequest);
if (telemetryTuple?.Item1 != null)
{
DependencyCollectorEventSource.Log.TrackingAnExistingTelemetryItemVerbose();
return(null);
}
// Create and initialize a new telemetry object
telemetry = ClientServerDependencyTracker.BeginTracking(this.telemetryClient);
this.AddTupleForWebDependencies(webRequest, telemetry, false);
if (string.IsNullOrEmpty(telemetry.Context.InstrumentationKey))
{
// Instrumentation key is probably empty, because the context has not yet had a chance to associate the requestTelemetry to the telemetry client yet.
// and get they instrumentation key from all possible sources in the process. Let's do that now.
this.telemetryClient.InitializeInstrumentationKey(telemetry);
}
telemetry.Name = resourceName;
telemetry.Target = DependencyTargetNameHelper.GetDependencyTargetName(url);
telemetry.Type = RemoteDependencyConstants.HTTP;
telemetry.Data = url.OriginalString;
telemetry.SetOperationDetail(RemoteDependencyConstants.HttpRequestOperationDetailName, webRequest);
Activity currentActivity = Activity.Current;
// Add the source instrumentation key header if collection is enabled, the request host is not in the excluded list and the same header doesn't already exist
if (this.setCorrelationHeaders && !this.correlationDomainExclusionList.Contains(url.Host))
{
string applicationId = null;
try
{
if (!string.IsNullOrEmpty(telemetry.Context.InstrumentationKey) &&
webRequest.Headers.GetNameValueHeaderValue(RequestResponseHeaders.RequestContextHeader,
RequestResponseHeaders.RequestContextCorrelationSourceKey) == null &&
(this.configuration.ApplicationIdProvider?.TryGetApplicationId(
telemetry.Context.InstrumentationKey, out applicationId) ?? false))
{
webRequest.Headers.SetNameValueHeaderValue(RequestResponseHeaders.RequestContextHeader,
RequestResponseHeaders.RequestContextCorrelationSourceKey, applicationId);
}
}
catch (Exception ex)
{
AppMapCorrelationEventSource.Log.SetCrossComponentCorrelationHeaderFailed(
ex.ToInvariantString());
}
if (this.injectLegacyHeaders)
{
// Add the root ID
var rootId = telemetry.Context.Operation.Id;
if (!string.IsNullOrEmpty(rootId) &&
webRequest.Headers[RequestResponseHeaders.StandardRootIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.StandardRootIdHeader, rootId);
}
// Add the parent ID
var parentId = telemetry.Id;
if (!string.IsNullOrEmpty(parentId))
{
if (webRequest.Headers[RequestResponseHeaders.StandardParentIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.StandardParentIdHeader, parentId);
}
}
}
if (currentActivity != null)
{
// ApplicationInsights only needs to inject W3C, potentially Request-Id and Correlation-Context
// headers for profiler instrumentation.
// in case of Http Desktop DiagnosticSourceListener they are injected in
// DiagnosticSource (with the System.Net.Http.Desktop.HttpRequestOut.Start event)
if (injectCorrelationHeaders)
{
if (currentActivity.IdFormat == ActivityIdFormat.W3C)
{
if (webRequest.Headers[W3C.W3CConstants.TraceParentHeader] == null)
{
webRequest.Headers.Add(W3C.W3CConstants.TraceParentHeader, currentActivity.Id);
}
if (webRequest.Headers[W3C.W3CConstants.TraceStateHeader] == null &&
!string.IsNullOrEmpty(currentActivity.TraceStateString))
{
webRequest.Headers.Add(W3C.W3CConstants.TraceStateHeader,
currentActivity.TraceStateString);
}
}
else
{
// Request-Id format
if (webRequest.Headers[RequestResponseHeaders.RequestIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.RequestIdHeader, telemetry.Id);
}
}
InjectCorrelationContext(webRequest.Headers, currentActivity);
}
}
}
// Active bug in .NET Fx diagnostics hook: https://github.com/dotnet/corefx/pull/40777
// Application Insights has to inject Request-Id to work it around
if (currentActivity?.IdFormat == ActivityIdFormat.W3C)
{
// if (this.injectRequestIdInW3CMode)
{
if (webRequest.Headers[RequestResponseHeaders.RequestIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.RequestIdHeader, string.Concat('|', telemetry.Context.Operation.Id, '.', telemetry.Id, '.'));
}
}
}
}
catch (Exception exception)
{
DependencyCollectorEventSource.Log.CallbackError(thisObj == null ? 0 : thisObj.GetHashCode(),
"OnBeginHttp", exception);
}
finally
{
Activity current = Activity.Current;
if (current?.OperationName == ClientServerDependencyTracker.DependencyActivityName)
{
current.Stop();
}
}
return(null);
}
//// netcoreapp 2.0 event
/// <summary>
/// Handler for Activity stop event (response is received for the outgoing request).
/// </summary>
internal void OnActivityStop(HttpResponseMessage response, HttpRequestMessage request, TaskStatus requestTaskStatus)
{
// Even though we have the IsEnabled filter to reject ApplicationInsights URLs before any events are fired, if there
// are multiple subscribers and one subscriber returns true to IsEnabled then all subscribers will receive the event.
if (this.applicationInsightsUrlFilter.IsApplicationInsightsUrl(request.RequestUri))
{
return;
}
Activity currentActivity = Activity.Current;
if (currentActivity == null)
{
DependencyCollectorEventSource.Log.CurrentActivityIsNull(HttpOutStopEventName);
return;
}
if (Activity.DefaultIdFormat == ActivityIdFormat.W3C &&
request.Headers.TryGetValues(W3C.W3CConstants.TraceParentHeader, out var parents) &&
parents.FirstOrDefault() != currentActivity.Id)
{
DependencyCollectorEventSource.Log.HttpRequestAlreadyInstrumented();
return;
}
DependencyCollectorEventSource.Log.HttpCoreDiagnosticSourceListenerStop(currentActivity.Id);
Uri requestUri = request.RequestUri;
var resourceName = request.Method.Method + " " + requestUri.AbsolutePath;
DependencyTelemetry telemetry = new DependencyTelemetry();
telemetry.SetOperationDetail(RemoteDependencyConstants.HttpRequestOperationDetailName, request);
// properly fill dependency telemetry operation context: OperationCorrelationTelemetryInitializer initializes child telemetry
if (currentActivity.IdFormat == ActivityIdFormat.W3C)
{
var traceId = currentActivity.TraceId.ToHexString();
telemetry.Context.Operation.Id = traceId;
if (currentActivity.ParentSpanId != default)
{
telemetry.Context.Operation.ParentId = W3CUtilities.FormatTelemetryId(traceId, currentActivity.ParentSpanId.ToHexString());
}
telemetry.Id = W3CUtilities.FormatTelemetryId(traceId, currentActivity.SpanId.ToHexString());
}
else
{
telemetry.Context.Operation.Id = currentActivity.RootId;
telemetry.Context.Operation.ParentId = currentActivity.ParentId;
telemetry.Id = currentActivity.Id;
}
foreach (var item in currentActivity.Baggage)
{
if (!telemetry.Properties.ContainsKey(item.Key))
{
telemetry.Properties[item.Key] = item.Value;
}
}
// TODO[tracestate]: remove, this is done in base SDK
if (!string.IsNullOrEmpty(currentActivity.TraceStateString) && !telemetry.Properties.ContainsKey(W3CConstants.TracestatePropertyKey))
{
telemetry.Properties.Add(W3CConstants.TracestatePropertyKey, currentActivity.TraceStateString);
}
this.client.Initialize(telemetry);
// If we started auxiliary Activity before to override the Id with W3C compatible one,
// now it's time to set end time on it
if (currentActivity.Duration == TimeSpan.Zero)
{
currentActivity.SetEndTime(DateTime.UtcNow);
}
telemetry.Timestamp = currentActivity.StartTimeUtc;
telemetry.Name = resourceName;
telemetry.Target = DependencyTargetNameHelper.GetDependencyTargetName(requestUri);
telemetry.Type = RemoteDependencyConstants.HTTP;
telemetry.Data = requestUri.OriginalString;
telemetry.Duration = currentActivity.Duration;
if (response != null)
{
this.ParseResponse(response, telemetry);
telemetry.SetOperationDetail(RemoteDependencyConstants.HttpResponseOperationDetailName, response);
}
else
{
if (this.pendingExceptions.TryRemove(currentActivity.Id, out Exception exception))
{
telemetry.Properties[RemoteDependencyConstants.DependencyErrorPropertyKey] = exception.GetBaseException().Message;
}
telemetry.ResultCode = requestTaskStatus.ToString();
telemetry.Success = false;
}
this.client.TrackDependency(telemetry);
}
/// <summary>
/// Common helper for all Begin Callbacks.
/// </summary>
/// <param name="thisObj">This object.</param>
/// <param name="injectCorrelationHeaders">Flag that enables Request-Id and Correlation-Context headers injection.
/// Should be set to true only for profiler and old versions of DiagnosticSource Http hook events.</param>
/// <returns>Null object as all context is maintained in this class via weak tables.</returns>
internal object OnBegin(object thisObj, bool injectCorrelationHeaders = true)
{
try
{
if (thisObj == null)
{
DependencyCollectorEventSource.Log.NotExpectedCallback(0, "OnBeginHttp", "thisObj == null");
return(null);
}
WebRequest webRequest = thisObj as WebRequest;
if (webRequest == null)
{
DependencyCollectorEventSource.Log.UnexpectedCallbackParameter("WebRequest");
}
var url = this.GetUrl(webRequest);
if (url == null)
{
DependencyCollectorEventSource.Log.NotExpectedCallback(thisObj.GetHashCode(), "OnBeginHttp", "resourceName is empty");
return(null);
}
string httpMethod = webRequest.Method;
string resourceName = url.AbsolutePath;
if (!string.IsNullOrEmpty(httpMethod))
{
resourceName = httpMethod + " " + resourceName;
}
DependencyCollectorEventSource.Log.BeginCallbackCalled(thisObj.GetHashCode(), resourceName);
if (this.applicationInsightsUrlFilter.IsApplicationInsightsUrl(url))
{
// Not logging as we will be logging for all outbound AI calls
return(null);
}
// If the object already exists, don't add again. This happens because either GetResponse or GetRequestStream could
// be the starting point for the outbound call.
DependencyTelemetry telemetry = null;
var telemetryTuple = this.GetTupleForWebDependencies(webRequest);
if (telemetryTuple != null)
{
if (telemetryTuple.Item1 != null)
{
telemetry = telemetryTuple.Item1;
DependencyCollectorEventSource.Log.TrackingAnExistingTelemetryItemVerbose();
return(null);
}
}
// Create and initialize a new telemetry object if needed
if (telemetry == null)
{
bool isCustomCreated = false;
telemetry = ClientServerDependencyTracker.BeginTracking(this.telemetryClient);
this.AddTupleForWebDependencies(webRequest, telemetry, isCustomCreated);
if (string.IsNullOrEmpty(telemetry.Context.InstrumentationKey))
{
// Instrumentation key is probably empty, because the context has not yet had a chance to associate the requestTelemetry to the telemetry client yet.
// and get they instrumentation key from all possible sources in the process. Let's do that now.
this.telemetryClient.Initialize(telemetry);
}
}
telemetry.Name = resourceName;
telemetry.Target = DependencyTargetNameHelper.GetDependencyTargetName(url);
telemetry.Type = RemoteDependencyConstants.HTTP;
telemetry.Data = url.OriginalString;
// Add the source instrumentation key header if collection is enabled, the request host is not in the excluded list and the same header doesn't already exist
if (this.setCorrelationHeaders &&
!this.correlationDomainExclusionList.Contains(url.Host))
{
try
{
if (!string.IsNullOrEmpty(telemetry.Context.InstrumentationKey) &&
webRequest.Headers.GetNameValueHeaderValue(RequestResponseHeaders.RequestContextHeader, RequestResponseHeaders.RequestContextCorrelationSourceKey) == null)
{
string appId;
if (this.correlationIdLookupHelper.TryGetXComponentCorrelationId(telemetry.Context.InstrumentationKey, out appId))
{
webRequest.Headers.SetNameValueHeaderValue(RequestResponseHeaders.RequestContextHeader, RequestResponseHeaders.RequestContextCorrelationSourceKey, appId);
}
}
}
catch (Exception ex)
{
AppMapCorrelationEventSource.Log.SetCrossComponentCorrelationHeaderFailed(ex.ToInvariantString());
}
// Add the root ID
var rootId = telemetry.Context.Operation.Id;
if (!string.IsNullOrEmpty(rootId) && webRequest.Headers[RequestResponseHeaders.StandardRootIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.StandardRootIdHeader, rootId);
}
// Add the parent ID
var parentId = telemetry.Id;
if (!string.IsNullOrEmpty(parentId))
{
if (webRequest.Headers[RequestResponseHeaders.StandardParentIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.StandardParentIdHeader, parentId);
}
}
// ApplicationInsights only need to inject Request-Id and Correlation-Context headers
// for profiler instrumentation, in case of Http Desktop DiagnosticSourceListener
// they are injected in DiagnosticSource (with the System.Net.Http.Desktop.HttpRequestOut.Start event)
if (injectCorrelationHeaders)
{
if (webRequest.Headers[RequestResponseHeaders.RequestIdHeader] == null)
{
webRequest.Headers.Add(RequestResponseHeaders.RequestIdHeader, telemetry.Id);
}
if (webRequest.Headers[RequestResponseHeaders.CorrelationContextHeader] == null)
{
var currentActivity = Activity.Current;
if (currentActivity != null && currentActivity.Baggage.Any())
{
webRequest.Headers.SetHeaderFromNameValueCollection(RequestResponseHeaders.CorrelationContextHeader, currentActivity.Baggage);
}
}
}
}
}
catch (Exception exception)
{
DependencyCollectorEventSource.Log.CallbackError(thisObj == null ? 0 : thisObj.GetHashCode(), "OnBeginHttp", exception);
}
return(null);
}
