public void Information(Exception exception, string fmt, params object[] vars)
{
var telemetry = new TraceTelemetry(string.Format(fmt, vars), SeverityLevel.Information);
telemetry.Properties.Add("Exception", ExceptionUtils.FormatException(exception, includeContext: true));
telemetryClient.TrackTrace(telemetry);
}
public ActionResult Login(LoginModel model, string returnUrl)
{
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
TraceTelemetry traceSample = new TraceTelemetry();
if (ModelState.IsValid && WebSecurity.Login(
model.UserName, model.Password, persistCookie: model.RememberMe))
{
// Migrate the user's shopping cart
MigrateShoppingCart(model.UserName);
//Sample Trace telemetry
traceSample.Message = "Login succesfull";
traceSample.SeverityLevel = SeverityLevel.Information;
telemetryClient.TrackTrace(traceSample);
return RedirectToLocal(returnUrl);
}
//Sample Trace telemetry
traceSample.Message = "Login failed";
traceSample.SeverityLevel = SeverityLevel.Information;
telemetryClient.TrackTrace(traceSample);
// If we got this far, something failed, redisplay form
ModelState.AddModelError("", "The user name or password provided is incorrect.");
return View(model);
}
public void RichPayloadEventSourceTraceSentTest()
{
var client = new TelemetryClient();
client.InstrumentationKey = Guid.NewGuid().ToString();
using (var listener = new Microsoft.ApplicationInsights.TestFramework.TestEventListener())
{
listener.EnableEvents(RichPayloadEventSource.Log.EventSourceInternal, EventLevel.Verbose, RichPayloadEventSource.Keywords.Traces);
var item = new TraceTelemetry("TestTrace", SeverityLevel.Information);
item.Context.Properties.Add("property1", "value1");
item.Context.User.Id = "testUserId";
item.Context.Operation.Id = Guid.NewGuid().ToString();
client.TrackTrace(item);
var actualEvent = listener.Messages.FirstOrDefault();
Assert.IsNotNull(actualEvent);
Assert.AreEqual(client.InstrumentationKey, actualEvent.Payload[0]);
object[] tags = actualEvent.Payload[1] as object[];
Assert.AreEqual("ai.user.id", ((Dictionary<string, object>)(tags[0]))["Key"]);
Assert.AreEqual("testUserId", ((Dictionary<string, object>)(tags[0]))["Value"]);
Assert.AreEqual("ai.operation.id", ((Dictionary<string, object>)(tags[1]))["Key"]);
Assert.AreEqual(item.Context.Operation.Id, ((Dictionary<string, object>)(tags[1]))["Value"]);
Assert.IsNotNull(actualEvent.Payload[2]);
}
}
//
// GET: /ShoppingCart/
public ActionResult Index()
{
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
var cart = ShoppingCart.GetCart(storeDB, this.HttpContext);
// Set up our ViewModel
var viewModel = new ShoppingCartViewModel
{
CartItems = cart.GetCartItems(),
CartTotal = cart.GetTotal()
};
foreach (var item in viewModel.CartItems)
{
Trace.Write("Cart item: " + item.AlbumId);
}
//Sample Trace Telemetry
TraceTelemetry sampleTelemetry = new TraceTelemetry();
sampleTelemetry.Message = "Normal response- Database";
sampleTelemetry.SeverityLevel = SeverityLevel.Information;
telemetryClient.TrackTrace(sampleTelemetry);
// Return the view
return View(viewModel);
}
public void ConstructorInitializesTraceTelemetryInstanceWithGivenMessage()
{
var item = new TraceTelemetry("TestMessage");
Assert.NotNull(item.Context);
Assert.NotNull(item.Properties);
Assert.Equal("TestMessage", item.Message);
Assert.Null(item.SeverityLevel);
}
public void ConstructorInitializesTraceTelemetryInstanceWithGivenMessageAndSeverityLevel()
{
var trace = new TraceTelemetry("TestMessage", SeverityLevel.Critical);
Assert.NotNull(trace.Context);
Assert.NotNull(trace.Properties);
Assert.Equal("TestMessage", trace.Message);
Assert.Equal(SeverityLevel.Critical, trace.SeverityLevel);
}
public void ConstructorInitializesDefaultTraceTelemetryInstance()
{
var item = new TraceTelemetry();
Assert.NotNull(item.Context);
Assert.NotNull(item.Properties);
Assert.Empty(item.Message);
Assert.Null(item.SeverityLevel);
}
public TraceTelemetryMessage(TraceTelemetry telemetry)
{
this.Time = telemetry.Timestamp.DateTime;
this.Name = "Trace";
this.Details = telemetry.Message;
this.Properties = telemetry.Properties.Count > 0 ? telemetry.Properties : null;
this.Type = "Trace";
this.Context = telemetry.Context;
}
public void SerializeWritesItemSeverityLevelAsExpectedByEndpoint()
{
var expected = new TraceTelemetry { SeverityLevel = SeverityLevel.Information };
((ITelemetry)expected).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem<TraceTelemetry, DataPlatformModel.MessageData>(expected);
Assert.Equal(Developer.Analytics.DataCollection.Model.v2.SeverityLevel.Information, item.Data.BaseData.SeverityLevel.Value);
}
public void Log(ITelemetry telemetry)
{
DC.TraceTelemetry trace = new DC.TraceTelemetry();
trace.Message = (telemetry as TraceTelemetry)?.Message;
foreach (var item in telemetry.Properties)
{
trace.Properties.Add(item.Key, item.Value);
}
client.TrackTrace(trace);
}
public void Can_Set_Operation_Id_On_Telemetry()
{
var telemetry = new TraceTelemetry();
var sut = new OperationIdTelemetryInitializer();
OperationIdContext.Create();
sut.Initialize(telemetry);
telemetry.Context.Operation.Id.Should().Be(OperationIdContext.Get());
}
public void SamplingScoreIsRandomIfUserIdAndOperationIdAreNotPresent()
{
var eventTelemetry = new EventTelemetry();
var traceTelemetry = new TraceTelemetry();
var eventTelemetrySamplingScore = SamplingScoreGenerator.GetSamplingScore(eventTelemetry);
var traceTelemetrySamplingScore = SamplingScoreGenerator.GetSamplingScore(traceTelemetry);
Assert.NotEqual(eventTelemetrySamplingScore, traceTelemetrySamplingScore);
}
public void InitializeSetsLocationIpToUserHostAddressFromXForwarderHeader()
{
var dictionary = new Dictionary<string, string> { { "X-Forwarded-For", "1.2.3.4" } };
var module = new TestableClientIpHeaderTelemetryInitializer(dictionary);
var telemetry = new TraceTelemetry();
module.Initialize(telemetry);
Assert.AreEqual("1.2.3.4", telemetry.Context.Location.Ip);
}
public void InitializeDoesNotOverrideCustomerParentOperationId()
{
var source = new TestableOperationCorrelationTelemetryInitializer(null);
var customerTelemetry = new TraceTelemetry("Text");
customerTelemetry.Context.Operation.ParentId = "CustomId";
source.Initialize(customerTelemetry);
Assert.AreEqual("CustomId", customerTelemetry.Context.Operation.ParentId);
}
public void Should_Not_Change_Operation_Id_If_Context_Not_Created()
{
var telemetry = new TraceTelemetry();
telemetry.Context.Operation.Id = "test";
var sut = new OperationIdTelemetryInitializer();
sut.Initialize(telemetry);
telemetry.Context.Operation.Id.Should().Be("test");
}
public void InitializeSetsRequestTelemetryRootOperaitonIdToOepraitonId()
{
var source = new TestableOperationCorrelationTelemetryInitializer(null);
var requestTelemetry = source.FakeContext.CreateRequestTelemetryPrivate();
var customerTelemetry = new TraceTelemetry("Text");
source.Initialize(customerTelemetry);
Assert.AreEqual(requestTelemetry.Id, requestTelemetry.Context.Operation.Id);
}
public void TraceApi(string componentName, string method, TimeSpan timespan, string properties)
{
var telemetry = new TraceTelemetry("Trace component call", SeverityLevel.Verbose);
telemetry.Properties.Add("component", componentName);
telemetry.Properties.Add("method", method);
telemetry.Properties.Add("timespan", timespan.ToString());
if (!string.IsNullOrWhiteSpace(properties))
telemetry.Properties.Add("properties", properties);
telemetryClient.TrackTrace(telemetry);
}
public void InitializeDoesNotOverrideCustomerRootOperationId()
{
var source = new TestableOperationCorrelationTelemetryInitializer(null);
var requestTelemetry = source.FakeContext.CreateRequestTelemetryPrivate();
requestTelemetry.Context.Operation.Id = "RootId";
var customerTelemetry = new TraceTelemetry("Text");
customerTelemetry.Context.Operation.Id = "CustomId";
source.Initialize(customerTelemetry);
Assert.AreEqual("CustomId", customerTelemetry.Context.Operation.Id);
}
public void TraceTelemetrySerializesToJsonCorrectly()
{
var expected = new TraceTelemetry();
expected.Message = "My Test";
expected.Properties.Add("Property2", "Value2");
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem<TraceTelemetry, DataPlatformModel.MessageData>(expected);
// NOTE: It's correct that we use the v1 name here, and therefore we test against it.
Assert.Equal(item.Name, Microsoft.Developer.Analytics.DataCollection.Model.v1.ItemType.Message);
Assert.Equal(typeof(DataPlatformModel.MessageData).Name, item.Data.BaseType);
Assert.Equal(2, item.Data.BaseData.Ver);
Assert.Equal(expected.Message, item.Data.BaseData.Message);
Assert.Equal(expected.Properties.ToArray(), item.Data.BaseData.Properties.ToArray());
}
//
// GET: /Home/
public async Task<ActionResult> Index()
{
// Get most popular albums
var albums = await GetTopSellingAlbums(6);
//var albums = GetTopSellingAlbums(6);
// Trigger some good old ADO code
var albumCount = GetTotalAlbumns();
Trace.Write(string.Format("Total number of Albums = {0} and Albums with 'The' = {1}", albumCount.Item1, albumCount.Item2));
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
//Sample Trace telemetry
TraceTelemetry traceSample = new TraceTelemetry();
traceSample.Message = "Slow response - database";
traceSample.SeverityLevel = SeverityLevel.Warning;
telemetryClient.TrackTrace(traceSample);
//Sample event telemetry
var properties = new Dictionary<string, string> { { "Property 1",string.Format("Album Count {0}" ,albumCount.Item1) } };
var measurements = new Dictionary<string, double> { { "Sample Meassurement", albumCount.Item1 } };
telemetryClient.TrackEvent("Top Selling Albums", properties, measurements);
//Sample exception telemetry
try
{
albumCount = null;
int count=albumCount.Item1;
}
catch (Exception ex)
{
telemetryClient.TrackException(ex, properties, measurements);
}
//Obtains the ip address from the request
var request = new RequestTelemetry();
request.Url = HttpContext.Request.Url;
request.Duration = System.TimeSpan.FromMilliseconds(100);
request.Success = false;
request.Name = "TEST REQUEST " + request.Name;
telemetryClient.TrackRequest(request);
return View(albums);
}
public void TraceTelemetryPropertiesFromContextAndItemSerializesToPropertiesInJson()
{
var expected = new TraceTelemetry();
expected.Context.GlobalProperties.Add("contextpropkey", "contextpropvalue");
expected.Properties.Add("TestProperty", "TestPropertyValue");
((ITelemetry)expected).Sanitize();
Assert.AreEqual(1, expected.Properties.Count);
Assert.AreEqual(1, expected.Context.GlobalProperties.Count);
Assert.IsTrue(expected.Properties.ContainsKey("TestProperty"));
Assert.IsTrue(expected.Context.GlobalProperties.ContainsKey("contextpropkey"));
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <AI.MessageData>(expected);
// Items added to both MessageData.Properties, and MessageData.Context.GlobalProperties are serialized to properties.
Assert.AreEqual(2, item.data.baseData.properties.Count);
Assert.IsTrue(item.data.baseData.properties.ContainsKey("contextpropkey"));
Assert.IsTrue(item.data.baseData.properties.ContainsKey("TestProperty"));
}
private void SendTrace(LoggingEvent loggingEvent)
{
try
{
loggingEvent.GetProperties();
string message = loggingEvent.RenderedMessage != null ? this.RenderLoggingEvent(loggingEvent) : "Log4Net Trace";
var trace = new TraceTelemetry(message)
{
SeverityLevel = this.GetSeverityLevel(loggingEvent.Level)
};
this.BuildCustomProperties(loggingEvent, trace);
this.telemetryClient.Track(trace);
}
catch (ArgumentNullException exception)
{
throw new LogException(exception.Message, exception);
}
}
public void NLogPropertyDuplicateKeyDuplicateValue()
{
var aiTarget = new PrivateObject(typeof(ApplicationInsightsTarget));
var logEventInfo = new LogEventInfo();
var loggerNameVal = "thisisaloggername";
logEventInfo.LoggerName = loggerNameVal;
logEventInfo.Properties.Add("LoggerName", loggerNameVal);
var traceTelemetry = new TraceTelemetry();
aiTarget.Invoke("BuildPropertyBag", logEventInfo, traceTelemetry);
Assert.IsTrue(traceTelemetry.Properties.ContainsKey("LoggerName"));
Assert.AreEqual(loggerNameVal, traceTelemetry.Properties["LoggerName"]);
}
private static void SerializeTraceTelemetry(TraceTelemetry traceTelemetry, JsonWriter writer)
{
writer.WriteStartObject();
traceTelemetry.WriteTelemetryName(writer, TraceTelemetry.TelemetryName);
traceTelemetry.WriteEnvelopeProperties(writer);
writer.WritePropertyName("data");
{
writer.WriteStartObject();
// TODO: MetricTelemetry should write type as this.data.baseType once Common Schema 2.0 compliant.
writer.WriteProperty("baseType", traceTelemetry.BaseType);
writer.WritePropertyName("baseData");
{
writer.WriteStartObject();
writer.WriteProperty("ver", traceTelemetry.Data.ver);
writer.WriteProperty("message", traceTelemetry.Message);
if (traceTelemetry.SeverityLevel.HasValue)
{
writer.WriteProperty("severityLevel", traceTelemetry.SeverityLevel.Value.ToString());
}
writer.WriteProperty("properties", traceTelemetry.Properties); // TODO: handle case where the property dictionary doesn't need to be instantiated.
writer.WriteEndObject();
}
writer.WriteEndObject();
}
writer.WriteEndObject();
}
public void TraceTelemetryImplementsISupportSamplingContract()
{
var telemetry = new TraceTelemetry();
Assert.NotNull(telemetry as ISupportSampling);
}
private void SendTrace(LogEventInfo logEvent)
{
var trace = new TraceTelemetry(logEvent.FormattedMessage)
{
SeverityLevel = this.GetSeverityLevel(logEvent.Level)
};
this.BuildPropertyBag(logEvent, trace);
this.telemetryClient.Track(trace);
}
/// <summary>
/// Send a trace message for display in Diagnostic Search.
/// </summary>
/// <param name="telemetry">Message with optional properties.</param>
public void TrackTrace(TraceTelemetry telemetry)
{
telemetry = telemetry ?? new TraceTelemetry();
this.Track(telemetry);
}
/// <summary>
/// Send a trace message for display in Diagnostic Search.
/// </summary>
/// <param name="message">Message to display.</param>
/// <param name="severityLevel">Trace severity level.</param>
/// <param name="properties">Named string values you can use to search and classify events.</param>
public void TrackTrace(string message, SeverityLevel severityLevel, IDictionary<string, string> properties)
{
TraceTelemetry telemetry = new TraceTelemetry(message, severityLevel);
if (properties != null && properties.Count > 0)
{
Utils.CopyDictionary(properties, telemetry.Context.Properties);
}
this.TrackTrace(telemetry);
}
public void Log(LogLevel logLevel, string message, System.Exception ex = null, Dictionary<string, string> propertyBag = null)
{
if (logLevel < _logManager.LogLevel)
{
return;
}
if (ex == null)
{
var tel = new TraceTelemetry(message, GetLevel(logLevel));
tel.Properties.Add(new KeyValuePair<string, string>("Machine_name", _machine));
tel.Properties.Add(new KeyValuePair<string, string>("User_name", _user));
tel.Properties.Add(new KeyValuePair<string, string>("Domain_name", _domain));
if (propertyBag != null)
{
foreach (var prop in propertyBag)
{
tel.Properties.Add(prop.Key, prop.Value);
}
}
_telemetryClient.TrackTrace(tel);
}
else
{
var tel = new ExceptionTelemetry(ex);
tel.Properties.Add(new KeyValuePair<string, string>("Message", message));
tel.Properties.Add(new KeyValuePair<string, string>("Machine_name", _machine));
tel.Properties.Add(new KeyValuePair<string, string>("User_name", _user));
tel.Properties.Add(new KeyValuePair<string, string>("Domain_name", _domain));
if (logLevel < LogLevel.Fatal)
{
tel.HandledAt = ExceptionHandledAt.UserCode;
}
else
{
tel.HandledAt = ExceptionHandledAt.Unhandled;
}
tel.SeverityLevel = GetLevel(logLevel);
if (propertyBag != null)
{
foreach (var prop in propertyBag)
{
tel.Properties.Add(prop.Key, prop.Value);
}
}
_telemetryClient.TrackException(tel);
if (logLevel == LogLevel.Fatal)
{
_telemetryClient.Flush(); // quickly empty the cache as this might be an application crash
}
}
}
public void InitializeDoesNotOverrideCustomerOperationName()
{
var source = new TestableOperationNameTelemetryInitializer();
source.FakeContext.CreateRequestTelemetryPrivate();
var customerTelemetry = new TraceTelemetry("Text");
customerTelemetry.Context.Operation.Name = "Name";
source.Initialize(customerTelemetry);
Assert.AreEqual("Name", customerTelemetry.Context.Operation.Name);
}
public ActionResult LogOff()
{
WebSecurity.Logout();
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
//Sample Trace telemetry
TraceTelemetry traceSample = new TraceTelemetry();
traceSample.Message = "Logged off";
traceSample.SeverityLevel = SeverityLevel.Information;
telemetryClient.TrackTrace(traceSample);
return RedirectToAction("Index", "Home");
}
public ActionResult Register()
{
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
//Sample Trace telemetry
TraceTelemetry traceSample = new TraceTelemetry();
traceSample.Message = "Database response - normal";
traceSample.SeverityLevel = SeverityLevel.Information;
telemetryClient.TrackTrace(traceSample);
return View();
}
public ActionResult Register(RegisterModel model)
{
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
WebSecurity.CreateUserAndAccount(model.UserName, model.Password);
WebSecurity.Login(model.UserName, model.Password);
// Migrate the newly registered user's shopping cart
MigrateShoppingCart(model.UserName);
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
//Sample Trace telemetry
TraceTelemetry traceSample = new TraceTelemetry();
traceSample.Message = "Registered succesfully";
traceSample.SeverityLevel = SeverityLevel.Information;
telemetryClient.TrackTrace(traceSample);
return RedirectToAction("Index", "Home");
}
catch (MembershipCreateUserException e)
{
var telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
//Sample Trace telemetry
TraceTelemetry traceSample = new TraceTelemetry();
traceSample.Message = "Registration failed";
traceSample.SeverityLevel = SeverityLevel.Error;
telemetryClient.TrackTrace(traceSample);
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
