private ITelemetryDocument ConvertRequestToTelemetryDocument(RequestTelemetry requestTelemetry)
{
var url = requestTelemetry.Url;
#if NET45
if (this.EvaluateDisabledTrackingProperties && url == null)
{
try
{
// some of the requestTelemetry properties might be deferred by using RequestTrackingTelemetryModule.DisableTrackingProperties.
// evaluate them now
// note: RequestTrackingUtilities.UpdateRequestTelemetryFromRequest is not used here, since not all fields need to be populated
var request = System.Web.HttpContext.Current?.Request;
url = request?.Unvalidated.Url;
}
catch (Exception e)
{
QuickPulseEventSource.Log.UnknownErrorEvent(e.ToInvariantString());
}
}
#endif
ITelemetryDocument telemetryDocument = new RequestTelemetryDocument()
{
Id = Guid.NewGuid(),
Version = TelemetryDocumentContractVersion,
Timestamp = requestTelemetry.Timestamp,
OperationId = TruncateValue(requestTelemetry.Context?.Operation?.Id),
Name = TruncateValue(requestTelemetry.Name),
Success = requestTelemetry.Success,
Duration = requestTelemetry.Duration,
ResponseCode = requestTelemetry.ResponseCode,
Url = url,
Properties = GetProperties(requestTelemetry),
};
SetCommonTelemetryDocumentData(telemetryDocument, requestTelemetry);
return(telemetryDocument);
}
public void TestRequestWithNonW3CCompatibleRequestIdHeader()
{
IWebHostBuilder Config(IWebHostBuilder builder)
{
return(builder.ConfigureServices(services =>
{
var aiOptions = new ApplicationInsightsServiceOptions();
// disable Dependency tracking (i.e. header injection)
aiOptions.EnableDependencyTrackingTelemetryModule = false;
services.AddApplicationInsightsTelemetry(aiOptions);
}));
}
using (var server = new InProcessServer(assemblyName, this.output, Config))
{
const string RequestPath = "/api/values";
var expectedRequestTelemetry = new RequestTelemetry();
expectedRequestTelemetry.Name = "GET Values/Get";
expectedRequestTelemetry.ResponseCode = "200";
expectedRequestTelemetry.Success = true;
expectedRequestTelemetry.Url = new Uri(server.BaseHost + RequestPath);
var headers = new Dictionary <string, string>
{
// Request-ID Correlation Header
{ "Request-Id", "|noncompatible.df07da90a5b27d93." },
{ "Request-Context", "appId=value" },
{ "Correlation-Context", "k1=v1,k2=v2" }
};
var actualRequest = this.ValidateRequestWithHeaders(server, RequestPath, headers, expectedRequestTelemetry);
Assert.NotEqual("noncompatible", actualRequest.tags["ai.operation.id"]);
Assert.Contains("|noncompatible.df07da90a5b27d93.", actualRequest.tags["ai.operation.parentId"]);
Assert.Equal("noncompatible", actualRequest.data.baseData.properties["ai_legacyRootId"]);
Assert.Equal("v1", actualRequest.data.baseData.properties["k1"]);
Assert.Equal("v2", actualRequest.data.baseData.properties["k2"]);
}
}
public void CanSetEnvelopeNameForSupportedTypes()
{
string testEnvelopeName = "Non_Standard*Envelope.Name";
var at = new AvailabilityTelemetry();
var dt = new DependencyTelemetry();
var et = new EventTelemetry();
var ext = new ExceptionTelemetry();
var mt = new MetricTelemetry();
var pvpt = new PageViewPerformanceTelemetry();
var pvt = new PageViewTelemetry();
var rt = new RequestTelemetry();
#pragma warning disable CS0618 // Type or member is obsolete
var pct = new PerformanceCounterTelemetry();
var sst = new SessionStateTelemetry();
#pragma warning restore CS0618 // Type or member is obsolete
Assert.IsTrue(at.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(dt.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(et.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(ext.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(mt.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(pvpt.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(pvt.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(rt.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(pct.TrySetEnvelopeName(testEnvelopeName));
Assert.IsTrue(sst.TrySetEnvelopeName(testEnvelopeName));
Assert.AreEqual(testEnvelopeName, at.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, dt.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, et.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, ext.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, mt.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, pvpt.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, pvt.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, rt.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, pct.Data.GetEnvelopeName());
Assert.AreEqual(testEnvelopeName, sst.Data.GetEnvelopeName());
}
public void QuickPulseTelemetryProcessorHandlesMultipleThreadsCorrectly()
{
// ARRANGE
var accumulatorManager = new QuickPulseDataAccumulatorManager();
var telemetryProcessor = new QuickPulseTelemetryProcessor(new SimpleTelemetryProcessorSpy());
((IQuickPulseTelemetryProcessor)telemetryProcessor).StartCollection(
accumulatorManager,
new Uri("http://microsoft.com"),
new TelemetryConfiguration()
{
InstrumentationKey = "some ikey"
});
// expected data loss if threading is misimplemented is around 10% (established through experiment)
int taskCount = 10000;
var tasks = new List <Task>(taskCount);
for (int i = 0; i < taskCount; i++)
{
var requestTelemetry = new RequestTelemetry()
{
ResponseCode = (i % 2 == 0) ? "200" : "500",
Duration = TimeSpan.FromMilliseconds(i),
Context = { InstrumentationKey = "some ikey" }
};
var task = new Task(() => telemetryProcessor.Process(requestTelemetry));
tasks.Add(task);
}
// ACT
tasks.ForEach(task => task.Start());
Task.WaitAll(tasks.ToArray());
// ASSERT
Assert.AreEqual(taskCount, accumulatorManager.CurrentDataAccumulator.AIRequestCount);
Assert.AreEqual(taskCount / 2, accumulatorManager.CurrentDataAccumulator.AIRequestSuccessCount);
}
public void InterceptCatchesExceptions()
{
var telemetryChannel = new FakeChannel();
var config = new TelemetryConfiguration("00000000-0000-0000-0000-000000000001", telemetryChannel);
var client = new TelemetryClient(config);
var service = new Mock <IFakeService>();
service.Setup(s => s.TestServiceMethod()).Throws(new InvalidOperationException("Test Exception Text"));
var collection = new ServiceCollection();
collection.AddSingleton(client);
MockBuilder.RegisterStatelessServiceContext(collection);
collection.AddSingleton(service.Object);
ServiceProvider provider = collection.BuildServiceProvider();
var gen = new ProxyGenerator();
var impl = (IFakeService)gen.CreateInterfaceProxyWithTargetInterface(
typeof(IFakeService),
new Type[0],
(object)null,
new InvokeInNewScopeInterceptor <IFakeService>(provider));
var ex = Assert.Throws <InvalidOperationException>(() => impl.TestServiceMethod());
Assert.Equal("Test Exception Text", ex.Message);
client.Flush();
RequestTelemetry requestTelemetry = telemetryChannel.Telemetry.OfType <RequestTelemetry>().FirstOrDefault();
Assert.NotNull(requestTelemetry);
Assert.False(requestTelemetry.Success);
ExceptionTelemetry exceptionTelemetry = telemetryChannel.Telemetry.OfType <ExceptionTelemetry>().FirstOrDefault();
Assert.NotNull(exceptionTelemetry);
Assert.Same(ex, exceptionTelemetry.Exception);
}
protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry)
{
if (!string.IsNullOrEmpty(telemetry.Context.Location.Ip))
{
//already populated
return;
}
if (string.IsNullOrEmpty(requestTelemetry.Context.Location.Ip))
{
string resultIp = null;
foreach (var name in this.HeaderNames)
{
var headerValue = platformContext.Request.Headers[name];
if (!string.IsNullOrEmpty(headerValue))
{
var ip = GetIpFromHeader(headerValue);
ip = CutPort(ip);
if (IsCorrectIpAddress(ip))
{
resultIp = ip;
break;
}
}
}
if (string.IsNullOrEmpty(resultIp))
{
var connectionFeature = platformContext.Features.Get <IHttpConnectionFeature>();
if (connectionFeature != null)
{
resultIp = connectionFeature.RemoteIpAddress.ToString();
}
}
requestTelemetry.Context.Location.Ip = resultIp;
}
telemetry.Context.Location.Ip = requestTelemetry.Context.Location.Ip;
}
public void CreateNewRequestTelemetry_Key_WithUrl()
{
var connector = new SyncWatcherConnector(new AppSettings {
ApplicationInsightsInstrumentationKey = "1"
}, new FakeISynchronize(),
new FakeIWebSocketConnectionsService(), new FakeIQuery(),
new FakeIWebLogger(), new TelemetryClient(new TelemetryConfiguration()));
var operationHolder = connector.CreateNewRequestTelemetry("/test");
Assert.AreEqual("FSW SyncWatcherConnector", operationHolder.Telemetry.Name);
var expected = new RequestTelemetry {
Url = new Uri("?f=/test", UriKind.Relative)
};
new CloudRoleNameInitializer($"{new AppSettings().ApplicationType}").Initialize(expected);
Assert.AreEqual(expected.Context.Cloud.RoleName, operationHolder.Telemetry.Context.Cloud.RoleName);
Assert.AreEqual(expected.Context.Cloud.RoleInstance, operationHolder.Telemetry.Context.Cloud.RoleInstance);
// check url
Assert.AreEqual(expected.Url, operationHolder.Telemetry.Url);
connector.EndRequestOperation(operationHolder);
}
public static void TrackRequest(string name, Uri uri, string code, bool success, long start, long end)
{
if (context == null)
{
Initialize();
}
if (!enable)
{
return;
}
RequestTelemetry request = new RequestTelemetry();
request.Name = name;
request.ResponseCode = code;
request.Success = success;
request.Url = uri;
request.Timestamp = DateTime.Now;
request.Start(start);
request.Context.Operation.Name = name;
request.Duration = new TimeSpan(end - start);
context.TrackRequest(request);
}
public void UpdateValidRequestTelemetryWithForceTrue()
{
var traceId = W3CUtilities.GenerateTraceId();
var parentSpanId = W3CUtilities.GenerateSpanId();
var spanId = W3CUtilities.GenerateSpanId();
var telemetry = new RequestTelemetry();
telemetry.Context.Operation.Id = traceId;
telemetry.Context.Operation.ParentId = $"|{traceId}.{parentSpanId}.";
telemetry.Id = $"|{traceId}.{spanId}.";
var a = new Activity("foo").Start();
a.SetTraceparent($"00-{traceId}-{spanId}-01");
a.UpdateTelemetry(telemetry, true);
Assert.AreEqual(traceId, telemetry.Context.Operation.Id);
Assert.AreEqual($"|{traceId}.{spanId}.", telemetry.Context.Operation.ParentId);
Assert.AreEqual($"|{traceId}.{a.GetSpanId()}.", telemetry.Id);
}
public void LogFunctionResult_HttpRequest_SendsCorrectTelemetry()
{
// If the scope has an HttpRequestMessage, we'll use the proper values
// for the RequestTelemetry
DateTime now = DateTime.UtcNow;
var result = CreateDefaultInstanceLogEntry();
var request = new HttpRequestMessage(HttpMethod.Post, "http://someuri/api/path");
request.Headers.Add("User-Agent", "my custom user agent");
var response = new HttpResponseMessage();
request.Properties[ApplicationInsightsScopeKeys.FunctionsHttpResponse] = response;
MockIpAddress(request, "1.2.3.4");
ILogger logger = CreateLogger(LogCategories.Results);
var scopeProps = CreateScopeDictionary(_invocationId, _functionShortName);
scopeProps[ApplicationInsightsScopeKeys.HttpRequest] = request;
using (logger.BeginScope(scopeProps))
{
logger.LogFunctionResult(_functionShortName, result, TimeSpan.FromMilliseconds(durationMs));
}
RequestTelemetry telemetry = _channel.Telemetries.Single() as RequestTelemetry;
Assert.Equal(_invocationId.ToString(), telemetry.Id);
Assert.Equal(_invocationId.ToString(), telemetry.Context.Operation.Id);
Assert.Equal(_functionShortName, telemetry.Name);
Assert.Equal(_functionShortName, telemetry.Context.Operation.Name);
Assert.Equal("1.2.3.4", telemetry.Context.Location.Ip);
Assert.Equal("POST", telemetry.Properties[LoggingKeys.HttpMethod]);
Assert.Equal(new Uri("http://someuri/api/path"), telemetry.Url);
Assert.Equal("my custom user agent", telemetry.Context.User.UserAgent);
Assert.Equal("200", telemetry.ResponseCode);
// TODO: Beef up validation to include properties
}
/// <summary>
/// Initializes <see cref="ITelemetry" /> device context.
/// </summary>
/// <param name="telemetry">The telemetry to initialize.</param>
public void Initialize(ITelemetry telemetry)
{
if (telemetry == null)
{
return;
}
Lazy <string> siteSlotName = new Lazy <string>(() =>
{
// We cannot cache these values as the environment variables can change on the fly.
return(GetAzureWebsiteUniqueSlotName());
});
if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleName))
{
telemetry.Context.Cloud.RoleName = siteSlotName.Value;
}
var internalContext = telemetry.Context.GetInternalContext();
if (string.IsNullOrEmpty(internalContext.NodeName) &&
!string.IsNullOrEmpty(siteSlotName.Value))
{
internalContext.NodeName = _siteNodeNames.GetOrAdd(siteSlotName.Value, p =>
{
// maintain previous behavior of node having the full url
return(p += WebAppSuffix);
});
}
RequestTelemetry request = telemetry as RequestTelemetry;
if (request != null)
{
var builder = new UriBuilder(request.Url);
builder.Host = "hello-world";
request.Url = builder.Uri;
}
}
public void InitializerOnSqlDependency()
{
Activity requestActivity = new Activity("request")
.Start()
.GenerateW3CContext();
RequestTelemetry request = new RequestTelemetry();
DependencyTelemetry sqlDependency = new DependencyTelemetry()
{
Type = "SQL"
};
sqlDependency.Context.GetInternalContext().SdkVersion = "rdddsc:12345";
string expectedId = sqlDependency.Id;
new W3COperationCorrelationTelemetryInitializer().Initialize(sqlDependency);
new W3COperationCorrelationTelemetryInitializer().Initialize(request);
Assert.AreEqual(request.Context.Operation.Id, sqlDependency.Context.Operation.Id);
Assert.AreEqual(request.Id, sqlDependency.Context.Operation.ParentId);
Assert.AreEqual(expectedId, sqlDependency.Id);
}
public void IF_Operation_details_not_provided_WHEN_Operation_is_disposed_SHOULD_log_new_operation()
{
//Arrange
var operation = Sut.StartRequestOperation(this, "RequestName", new Dictionary <string, string>());
var decoratedRequestTelemetry = new RequestTelemetry();
MockTelemetryDecorator.Where_Decorate_returns(decoratedRequestTelemetry);
//Act
operation.Dispose();
//Assert
MockTelemetryDecorator.Mock.Verify <RequestTelemetry>(x => x.DecorateTelemetry(
It.Is <RequestTelemetry>(y => y.Name == "RequestName"),
nameof(StartRequestOperationTests),
"IF_Operation_details_not_provided_WHEN_Operation_is_disposed_SHOULD_log_new_operation",
It.Is <IAnalyticsOperation>(y => y.Name == "NewRequest"),
Sut.CurrentSession,
It.IsAny <Dictionary <string, object> >()));
MockTelemetryClient.Mock.Verify(x => x.TrackRequest(decoratedRequestTelemetry));
MockConsoleLogger.Mock.Verify(x => x.LogOperation("RequestName", It.IsAny <TimeSpan>()));
}
internal IOperationHolder <RequestTelemetry> CreateNewRequestTelemetry(string?fullFilePath = null)
{
if (_telemetryClient == null || string.IsNullOrEmpty(_appSettings !
.ApplicationInsightsInstrumentationKey))
{
return(new EmptyOperationHolder <RequestTelemetry>());
}
var requestTelemetry = new RequestTelemetry {
Name = "FSW " + nameof(SyncWatcherConnector)
};
var operation = _telemetryClient.StartOperation(requestTelemetry);
operation.Telemetry.Timestamp = DateTimeOffset.UtcNow;
operation.Telemetry.Source = "FileSystem";
if (!string.IsNullOrEmpty(fullFilePath))
{
operation.Telemetry.Url = new Uri($"?f={fullFilePath}", UriKind.Relative);
}
new CloudRoleNameInitializer($"{_appSettings.ApplicationType}").Initialize(requestTelemetry);
return(operation);
}
void IWcfTelemetryModule.OnBeginRequest(IOperationContext operation)
{
if (operation == null)
{
throw new ArgumentNullException("operation");
}
if (this.telemetryClient == null)
{
return;
}
RequestTelemetry telemetry = operation.Request;
// if ASP.NET has already started the request, leave the start time alone.
if (operation.OwnsRequest)
{
telemetry.Start();
}
telemetry.Url = operation.EndpointUri;
telemetry.Name = operation.OperationName;
telemetry.Properties["soapAction"] = operation.SoapAction;
var httpHeaders = operation.GetHttpRequestHeaders();
if (httpHeaders != null)
{
telemetry.Properties["httpMethod"] = httpHeaders.Method;
if (operation.ToHeader != null)
{
// overwrite it for WebHttpBinding requests
telemetry.Url = operation.ToHeader;
}
}
// run telemetry initializers here, while the request message is still open
this.telemetryClient.Initialize(telemetry);
}
public void Process_MultipleSuccessfulResponseCodes_SetsSuccessToTrueForRequestTelemetryWithSuccessfulResponseCode(
int responseCode)
{
var telemetry = new RequestTelemetry()
{
ResponseCode = responseCode.ToString(),
Success = false
};
using (var test = TelemetryProcessorTest <RequestTelemetryProcessor> .Create())
{
test.NextProcessor.Setup(x => x.Process(It.IsNotNull <RequestTelemetry>()))
.Verifiable();
test.Processor.SuccessfulResponseCodes.Add(400);
test.Processor.SuccessfulResponseCodes.Add(404);
test.Processor.Process(telemetry);
Assert.True(telemetry.Success);
}
}
public void BeginWebTrackingWithParentCallContextReturnsOperationItemWithTelemetryItem()
{
var requestTelemetry = new RequestTelemetry {
Id = "|guid.1234_"
};
var correlationContext = new Dictionary <string, string> {
["k"] = "v"
};
CorrelationHelper.SetOperationContext(requestTelemetry, correlationContext);
var telemetry = ClientServerDependencyTracker.BeginTracking(this.telemetryClient);
Assert.AreEqual("|guid.1234_", telemetry.Context.Operation.ParentId);
Assert.AreEqual("guid", telemetry.Context.Operation.Id);
var properties = telemetry.Context.Properties;
Assert.AreEqual(1, properties.Count);
Assert.AreEqual("v", properties["k"]);
CorrelationHelper.CleanOperationContext();
}
public void SerializesKnownTelemetryWithExtension()
{
RequestTelemetry request = new RequestTelemetry();
int intField = 42;
string stringField = "value";
request.Extension = new MyTestExtension {
myIntField = intField, myStringField = stringField
};
byte[] bytes = JsonSerializer.Serialize(request, compress: false);
JsonReader reader = new JsonTextReader(new StringReader(Encoding.UTF8.GetString(bytes, 0, bytes.Length)));
reader.DateParseHandling = DateParseHandling.None;
JObject obj = JObject.Load(reader);
TelemetryItem <RequestTelemetry> data = obj.ToObject <TelemetryItem <RequestTelemetry> >();
Assert.IsTrue(data.data.baseData.Properties["myIntField"] == intField.ToString());
Assert.IsTrue(data.data.baseData.Properties["myStringField"] == stringField);
}
public void RichPayloadEventSourceNestedOperationStartStopTest()
{
if (IsRunningOnEnvironmentSupportingRichPayloadEventSource())
{
var client = CreateTelemetryClient();
using (var listener = new TestFramework.TestEventListener())
{
listener.EnableEvents(RichPayloadEventSource.Log.EventSourceInternal, EventLevel.Informational, RichPayloadEventSource.Keywords.Operations);
// Simulate a Start/Stop request operation
var requestTelemetry = new RequestTelemetry {
Name = "Request"
};
var nestedOperation = new DependencyTelemetry {
Name = "Dependency"
};
using (client.StartOperation(requestTelemetry))
{
using (client.StartOperation(nestedOperation))
{
}
}
// Expect exactly four events (start, start, stop, stop)
var actualEvents = listener.Messages.Where(m => m.Keywords.HasFlag(RichPayloadEventSource.Keywords.Operations)).Take(4).ToArray();
VerifyOperationEvent(requestTelemetry, RequestTelemetry.TelemetryName, EventOpcode.Start, actualEvents[0]);
VerifyOperationEvent(nestedOperation, OperationTelemetry.TelemetryName, EventOpcode.Start, actualEvents[1]);
VerifyOperationEvent(nestedOperation, OperationTelemetry.TelemetryName, EventOpcode.Stop, actualEvents[2]);
VerifyOperationEvent(requestTelemetry, RequestTelemetry.TelemetryName, EventOpcode.Stop, actualEvents[3]);
}
}
else
{
// 4.5 doesn't have RichPayload events
Assert.IsNull(RichPayloadEventSource.Log.EventSourceInternal);
}
}
private void ValidateServiceBusRequest(
RequestTelemetry request,
bool success,
string endpoint,
string queueName,
string operationName,
string operationId,
string parentId)
{
Assert.Equal($"type:Azure Service Bus | name:{queueName} | endpoint:{endpoint}/", request.Source);
Assert.Null(request.Url);
Assert.Equal(operationName, request.Name);
Assert.True(request.Properties.ContainsKey(LogConstants.FunctionExecutionTimeKey));
Assert.True(double.TryParse(request.Properties[LogConstants.FunctionExecutionTimeKey], out double functionDuration));
Assert.True(request.Duration.TotalMilliseconds >= functionDuration);
Assert.DoesNotContain(request.Properties, p => p.Key == LogConstants.HttpMethodKey);
TelemetryValidationHelpers.ValidateRequest(request, operationName, operationId, parentId, LogCategories.Results,
success ? LogLevel.Information : LogLevel.Error, success);
}
public void InitializeWithActivityWinsOverCallContext()
{
CallContextHelpers.SaveOperationContext(new OperationContextForCallContext {
RootOperationId = "callContextRoot"
});
var currentActivity = new Activity("test");
currentActivity.AddTag("OperationName", "operation");
currentActivity.AddBaggage("k1", "v1");
currentActivity.Start();
var telemetry = new RequestTelemetry();
(new OperationCorrelationTelemetryInitializer()).Initialize(telemetry);
Assert.AreEqual(currentActivity.TraceId.ToHexString(), telemetry.Context.Operation.Id);
Assert.AreEqual(W3CUtilities.FormatTelemetryId(currentActivity.TraceId.ToHexString(), currentActivity.SpanId.ToHexString()), telemetry.Context.Operation.ParentId);
Assert.AreEqual("operation", telemetry.Context.Operation.Name);
Assert.AreEqual(1, telemetry.Properties.Count);
Assert.AreEqual("v1", telemetry.Properties["k1"]);
currentActivity.Stop();
}
private void AddRequestProperties(EventData eventData, RequestTelemetry request)
{
IDictionary <string, object> eventPayload = eventData.Payload;
var requestMetadata = new EventMetadata(RequestData.RequestMetadataKind);
eventData.SetMetadata(requestMetadata);
eventPayload.Add(TelemetryTypeProperty, "request");
eventPayload.Add(nameof(request.Name), request.Name);
requestMetadata.Properties.Add(RequestData.RequestNamePropertyMoniker, nameof(request.Name));
eventPayload.Add(nameof(request.Duration), request.Duration);
requestMetadata.Properties.Add(RequestData.DurationPropertyMoniker, nameof(request.Duration));
requestMetadata.Properties.Add(RequestData.DurationUnitMoniker, nameof(TimeSpan));
if (!string.IsNullOrEmpty(request.Id))
{
eventPayload.Add(nameof(request.Id), request.Id);
}
if (!string.IsNullOrEmpty(request.ResponseCode))
{
eventPayload.Add(nameof(request.ResponseCode), request.ResponseCode);
requestMetadata.Properties.Add(RequestData.ResponseCodePropertyMoniker, nameof(request.ResponseCode));
}
if (request.Success.HasValue)
{
eventPayload.Add(nameof(request.Success), request.Success.Value);
requestMetadata.Properties.Add(RequestData.IsSuccessPropertyMoniker, nameof(request.Success));
}
if (request.Url != null)
{
eventPayload.Add(nameof(request.Url), request.Url.ToString());
}
if (!string.IsNullOrEmpty(request.Source))
{
eventPayload.Add(nameof(request.Source), request.Source);
}
}
public void TestRequestWithNonW3CCompatibleNonHierrachicalRequestIdHeader()
{
IWebHostBuilder Config(IWebHostBuilder builder)
{
return(builder.ConfigureServices(services =>
{
services.AddApplicationInsightsTelemetry();
// disable Dependency tracking (i.e. header injection)
services.Remove(services.FirstOrDefault(sd => sd.ImplementationType == typeof(DependencyTrackingTelemetryModule)));
}));
}
using (var server = new InProcessServer(assemblyName, this.output, Config))
{
const string RequestPath = "/api/values";
var expectedRequestTelemetry = new RequestTelemetry();
expectedRequestTelemetry.Name = "GET Values/Get";
expectedRequestTelemetry.ResponseCode = "200";
expectedRequestTelemetry.Success = true;
expectedRequestTelemetry.Url = new Uri(server.BaseHost + RequestPath);
var headers = new Dictionary <string, string>
{
// Request-ID Correlation Header
{ "Request-Id", "somerandomidnotinanyformat" },
{ "Request-Context", "appId=value" },
{ "Correlation-Context", "k1=v1,k2=v2" }
};
var actualRequest = this.ValidateRequestWithHeaders(server, RequestPath, headers, expectedRequestTelemetry);
Assert.NotEqual("noncompatible", actualRequest.tags["ai.operation.id"]);
Assert.Contains("somerandomidnotinanyformat", actualRequest.tags["ai.operation.parentId"]);
Assert.Equal("somerandomidnotinanyformat", actualRequest.data.baseData.properties["ai_legacyRootId"]);
Assert.Equal("v1", actualRequest.data.baseData.properties["k1"]);
Assert.Equal("v2", actualRequest.data.baseData.properties["k2"]);
}
}
private static void UpdateRequestTelemetryFromPlatformContext(RequestTelemetry requestTelemetry, HttpContext platformContext)
{
if (platformContext.Request.Cookies != null && platformContext.Request.Cookies.ContainsKey(WebUserCookieName))
{
var userCookieValue = platformContext.Request.Cookies[WebUserCookieName];
if (!string.IsNullOrEmpty(userCookieValue))
{
var userCookieParts = ((string)userCookieValue).Split('|');
if (userCookieParts.Length >= 2)
{
// todo: add tracing
DateTimeOffset acquisitionDate = DateTimeOffset.MinValue;
if (!string.IsNullOrEmpty(userCookieParts[1]) &&
DateTimeOffset.TryParse(userCookieParts[1], CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal, out acquisitionDate))
{
requestTelemetry.Context.User.Id = userCookieParts[0];
requestTelemetry.Context.User.AcquisitionDate = acquisitionDate;
}
}
}
}
}
protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry)
{
if (!string.IsNullOrEmpty(telemetry.Context.User.Id))
{
return;
}
if (string.IsNullOrEmpty(requestTelemetry.Context.User.Id))
{
UpdateRequestTelemetryFromPlatformContext(requestTelemetry, platformContext);
}
if (!string.IsNullOrEmpty(requestTelemetry.Context.User.Id))
{
telemetry.Context.User.Id = requestTelemetry.Context.User.Id;
}
if (requestTelemetry.Context.User.AcquisitionDate.HasValue)
{
telemetry.Context.User.AcquisitionDate = requestTelemetry.Context.User.AcquisitionDate;
}
}
/// <summary>
/// Initializes role name, role instance name and node name for Azure Web App case.
/// </summary>
/// <param name="platformContext">Platform context.</param>
/// <param name="requestTelemetry">Request telemetry.</param>
/// <param name="telemetry">Telemetry item.</param>
protected override void OnInitializeTelemetry(HttpContext platformContext, RequestTelemetry requestTelemetry, ITelemetry telemetry)
{
if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleName))
{
string name = LazyInitializer.EnsureInitialized(ref this.roleName, this.GetRoleName);
telemetry.Context.Cloud.RoleName = name;
}
if (string.IsNullOrEmpty(telemetry.Context.Cloud.RoleInstance))
{
string name = LazyInitializer.EnsureInitialized(ref this.roleInstanceName, this.GetRoleInstanceName);
telemetry.Context.Cloud.RoleInstance = name;
}
InternalContext internalContext = telemetry.Context.GetInternalContext();
if (string.IsNullOrEmpty(internalContext.NodeName))
{
string name = LazyInitializer.EnsureInitialized(ref this.roleInstanceName, this.GetRoleInstanceName);
internalContext.NodeName = name;
}
}
public void TestRequestTelemetry()
{
var telemetry = new Microsoft.ApplicationInsights.TelemetryClient {
InstrumentationKey = "2119853a-bc51-429e-962d-4b7f9cda9a3f"
.ToString()
};
for (int i = 0; i < 1000; i++)
{
RequestTelemetry requestTelemetry = new RequestTelemetry();
DateTime dt = DateTime.Now;
requestTelemetry.Duration = new TimeSpan(dt.Hour, dt.Minute, dt.Second);
requestTelemetry.Name = "TestRequestTelemetry";
requestTelemetry.Url = new Uri("Dynamics.Ready.2019.com/UnitTests");
requestTelemetry.Sequence = i.ToString();
requestTelemetry.ResponseCode = "200";
telemetry.TrackRequest(requestTelemetry);
}
telemetry.Flush();
}
private async Task RunHttpTest(string functionName, string scenario, HttpStatusCode expectedStatusCode, bool functionSuccess)
{
HttpRequestMessage request = new HttpRequestMessage
{
RequestUri = new Uri($"https://localhost/api/{functionName}"),
Method = HttpMethod.Post,
};
string functionTrace = $"Function trace: {Guid.NewGuid().ToString()}";
JObject input = new JObject()
{
{ "scenario", scenario },
{ "container", "not-used" },
{ "value", functionTrace },
};
request.Content = new StringContent(input.ToString());
request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
request.Content.Headers.ContentLength = input.ToString().Length;
HttpResponseMessage response = await _fixture.HttpClient.SendAsync(request);
Assert.Equal(expectedStatusCode, response.StatusCode);
string invocationId = ValidateEndToEndTest(functionName, functionTrace, functionSuccess);
// Perform some additional validation on HTTP properties
RequestTelemetry requestTelemetry = _fixture.Channel.Telemetries
.OfType <RequestTelemetry>()
.Where(t => GetInvocationId(t) == invocationId)
.Single();
Assert.Equal(((int)expectedStatusCode).ToString(), requestTelemetry.ResponseCode);
Assert.Equal("POST", requestTelemetry.Properties["HttpMethod"]);
Assert.Equal(request.RequestUri, requestTelemetry.Url);
Assert.Equal(functionSuccess, requestTelemetry.Success);
}
public CustomActivity(string operationName, CustomActivity parentActivity, OperationType operationType, string target) : base(operationName)
{
MyOperationType = operationType;
MyTelemetryTarget = target;
if (parentActivity != null)
{
SetParent(operationName, parentActivity);
this.Start();
return;
}
this.tc = new TelemetryClient();
this.Start();
switch (operationType)
{
case OperationType.DependencyOperation:
MyDependencyTelemetry = new DependencyTelemetry(operationName, MyTelemetryTarget, null, null, DateTimeOffset.UtcNow, TimeSpan.Zero, "not disposed", true);
MyDependencyTelemetry.Context.Operation.Id = this.Id;
tc.Context.Operation.Id = MyDependencyTelemetry.Context.Operation.Id;
break;
case OperationType.RequestOperation:
MyRequestTelemetry = new RequestTelemetry(operationName, DateTimeOffset.UtcNow, TimeSpan.Zero, "not disposed", true);
MyRequestTelemetry.Context.Operation.Id = this.Id;
tc.Context.Operation.Id = MyRequestTelemetry.Context.Operation.Id;
if (!String.IsNullOrEmpty(MyTelemetryTarget))
{
if (Uri.TryCreate(MyTelemetryTarget, UriKind.Absolute, out Uri Uriresult))
{
MyRequestTelemetry.Url = Uriresult;
}
}
break;
default:
throw new NotImplementedException("Implement OperationType " + operationType);
}
}
public void Initializer_IsIdempotent_HttpRequest()
{
string functionName = "MyFunction";
string status = "409";
Uri uri = new Uri("http://localhost/api/somemethod?secret=secret");
// Simulate an HttpRequest
var request = new RequestTelemetry
{
Url = uri,
ResponseCode = status,
Name = "POST /api/somemethod",
};
Activity requestActivity = new Activity("dummy");
requestActivity.Start();
requestActivity.AddTag(LogConstants.NameKey, functionName);
requestActivity.AddTag(LogConstants.SucceededKey, "true");
var initializer = new WebJobsTelemetryInitializer(new WebJobsSdkVersionProvider());
initializer.Initialize(request);
initializer.Initialize(request);
Assert.Equal(functionName, request.Context.Operation.Name);
Assert.Equal(status, request.ResponseCode);
Assert.Equal(true, request.Success);
Assert.Equal(functionName, request.Name);
Assert.True(request.Properties.TryGetValue(LogConstants.HttpMethodKey, out var actualHttpMethod));
Assert.Equal("POST", actualHttpMethod);
Assert.True(request.Properties.TryGetValue(LogConstants.HttpPathKey, out var actualHttpPath));
Assert.Equal("/api/somemethod", actualHttpPath);
Assert.DoesNotContain(request.Properties, p => p.Key == LogConstants.SucceededKey);
}
private static void SerializeRequestTelemetry(RequestTelemetry requestTelemetry, JsonWriter jsonWriter)
{
jsonWriter.WriteStartObject();
requestTelemetry.WriteTelemetryName(jsonWriter, RequestTelemetry.TelemetryName);
requestTelemetry.WriteEnvelopeProperties(jsonWriter);
jsonWriter.WritePropertyName("data");
{
jsonWriter.WriteStartObject();
// TODO: MetricTelemetry should write type as this.data.baseType once Common Schema 2.0 compliant.
jsonWriter.WriteProperty("baseType", requestTelemetry.BaseType);
jsonWriter.WritePropertyName("baseData");
{
jsonWriter.WriteStartObject();
jsonWriter.WriteProperty("ver", requestTelemetry.Data.ver);
jsonWriter.WriteProperty("id", requestTelemetry.Data.id);
jsonWriter.WriteProperty("name", requestTelemetry.Data.name);
jsonWriter.WriteProperty("startTime", requestTelemetry.Timestamp);
jsonWriter.WriteProperty("duration", requestTelemetry.Duration);
jsonWriter.WriteProperty("success", requestTelemetry.Data.success);
jsonWriter.WriteProperty("responseCode", requestTelemetry.Data.responseCode);
jsonWriter.WriteProperty("url", requestTelemetry.Data.url);
jsonWriter.WriteProperty("measurements", requestTelemetry.Data.measurements);
jsonWriter.WriteProperty("httpMethod", requestTelemetry.Data.httpMethod);
jsonWriter.WriteProperty("properties", requestTelemetry.Data.properties);
jsonWriter.WriteEndObject();
}
jsonWriter.WriteEndObject();
}
jsonWriter.WriteEndObject();
}
/// <summary>
/// Send information about a request handled by the application.
/// </summary>
internal void TrackRequest(RequestTelemetry request)
{
if (request == null)
{
request = new RequestTelemetry();
}
this.Track(request);
}
