public void SerializeWritesInnerExceptionWithOuterIdLinkingItToItsParentException()
{
var innerException = new Exception();
var exception = new Exception("Test Exception", innerException);
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(exception.GetHashCode(), item.Data.BaseData.Exceptions[1].OuterId);
}
public void SerializeWritesStateAsExpectedByEndpoint()
{
var telemetry = new SessionStateTelemetry {
State = SessionState.End
};
TelemetryItem <SessionStateData> envelope = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <SessionStateTelemetry, SessionStateData>(telemetry);
Assert.Equal(DataPlatformModel.SessionState.End, envelope.Data.BaseData.State);
Assert.Equal(2, envelope.Data.BaseData.Ver);
}
public void SerializeWritesPropertiesAsExpectedByEndpoint()
{
ExceptionTelemetry expected = CreateExceptionTelemetry();
expected.Properties.Add("TestProperty", "TestValue");
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(expected.Properties.ToArray(), item.Data.BaseData.Properties.ToArray());
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
ExceptionTelemetry original = new ExceptionTelemetry();
original.Exception = null;
original.SeverityLevel = null;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void SerializeWritesMetricsAsExpectedByEndpoint()
{
ExceptionTelemetry expected = CreateExceptionTelemetry();
expected.Metrics.Add("TestMetric", 4.2);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(expected.Metrics.ToArray(), item.Data.BaseData.Measurements.ToArray());
}
public void SerializeWritesSingleInnerExceptionOfAggregateExceptionOnlyOnce()
{
ServiceLocator.AddService <IPlatformService>(new PlatformService());
var exception = new AggregateException("Test Exception", new Exception());
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(2, item.Data.BaseData.Exceptions.Count);
}
public void SerializeWritesInnerExceptionsOfAggregateExceptionAsAdditionalItemsInExceptionsArrayExpectedByEndpoint()
{
var exception = new AggregateException("Test Exception", new[] { new Exception(), new Exception() });
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(exception.GetHashCode(), item.Data.BaseData.Exceptions[1].OuterId);
Assert.Equal(exception.GetHashCode(), item.Data.BaseData.Exceptions[2].OuterId);
}
public void SerializeWritesInnerExceptionAsAdditionalItemInExceptionsArrayExpectedByEndpoint()
{
var innerException = new Exception("Inner Message");
var exception = new Exception("Root Message", innerException);
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.Equal(innerException.Message, item.Data.BaseData.Exceptions[1].Message);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
TraceTelemetry original = new TraceTelemetry();
original.Message = null;
original.SeverityLevel = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <TraceTelemetry, DataPlatformModel.MessageData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void MetricTelemetrySerializesStructuredIKeyCorrectlyPreservingCaseOfPrefix()
{
var metricTelemetry = new MetricTelemetry();
metricTelemetry.Context.InstrumentationKey = "AIC-" + Guid.NewGuid().ToString();
((ITelemetry)metricTelemetry).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <MetricTelemetry, DataPlatformModel.MetricData>(metricTelemetry);
Assert.Equal(metricTelemetry.Context.InstrumentationKey, item.IKey);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
PerformanceCounterTelemetry original = new PerformanceCounterTelemetry();
original.CategoryName = null;
original.CounterName = null;
original.InstanceName = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <PerformanceCounterTelemetry, DataPlatformModel.PerformanceCounterData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void SerializePopulatesRequiredFieldsOfExceptionTelemetry()
{
var exceptionTelemetry = new ExceptionTelemetry();
exceptionTelemetry.Context.InstrumentationKey = Guid.NewGuid().ToString();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(exceptionTelemetry);
Assert.Equal(2, item.Data.BaseData.Ver);
Assert.NotNull(item.Data.BaseData.HandledAt);
Assert.NotNull(item.Data.BaseData.Exceptions);
Assert.Equal(0, item.Data.BaseData.Exceptions.Count); // constructor without parameters does not initialize exception object
}
public void SerializeWritesHasFullStackPropertyAsItIsExpectedByEndpoint()
{
using (var stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
var exception = CreateExceptionWithStackTrace();
ExceptionTelemetry expected = CreateExceptionTelemetry(exception);
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <ExceptionTelemetry, DataPlatformModel.ExceptionData>(expected);
Assert.True(item.Data.BaseData.Exceptions[0].HasFullStack);
}
}
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 SerializeWritesNullValuesAsExpectedByEndpoint()
{
MetricTelemetry original = new MetricTelemetry();
original.Name = null;
original.Max = null;
original.Min = null;
original.Count = null;
original.StandardDeviation = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <MetricTelemetry, DataPlatformModel.MetricData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
RequestTelemetry original = new RequestTelemetry();
original.HttpMethod = null;
original.Id = null;
original.Name = null;
original.ResponseCode = null;
original.Url = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <RequestTelemetry, DataPlatformModel.RequestData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
DependencyTelemetry original = new DependencyTelemetry();
original.Name = null;
original.CommandName = null;
original.DependencyTypeName = null;
original.Success = null;
original.Async = null;
original.DependencyKind = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <DependencyTelemetry, DataPlatformModel.RemoteDependencyData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
public void SerializePopulatesRequiredFieldsOfRequestTelemetry()
{
using (StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture))
{
var requestTelemetry = new RequestTelemetry();
requestTelemetry.Context.InstrumentationKey = Guid.NewGuid().ToString();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <RequestTelemetry, DataPlatformModel.RequestData>(requestTelemetry);
Assert.Equal(2, item.Data.BaseData.Ver);
Assert.NotNull(item.Data.BaseData.Id);
Assert.NotNull(item.Data.BaseData.StartTime);
Assert.Equal("200", item.Data.BaseData.ResponseCode);
Assert.Equal(new TimeSpan(), item.Data.BaseData.Duration);
Assert.True(item.Data.BaseData.Success);
}
}
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());
}
public void EventTelemetrySerializesToJsonCorrectly()
{
var expected = new EventTelemetry();
expected.Name = "Test Event";
expected.Properties["Test Property"] = "Test Value";
expected.Metrics["Test Property"] = 4.2;
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <EventTelemetry, DataPlatformModel.EventData>(expected);
// NOTE: It's correct that we use the v1 name here, and therefore we test against it.
Assert.Equal(Microsoft.Developer.Analytics.DataCollection.Model.v1.ItemType.Event, item.Name);
Assert.Equal(typeof(DataPlatformModel.EventData).Name, item.Data.BaseType);
Assert.Equal(2, item.Data.BaseData.Ver);
Assert.Equal(expected.Name, item.Data.BaseData.Name);
Assert.Equal(expected.Metrics.ToArray(), item.Data.BaseData.Measurements.ToArray());
Assert.Equal(expected.Properties.ToArray(), item.Data.BaseData.Properties.ToArray());
}
public void RemoteDependencyTelemetrySerializesToJson()
{
DependencyTelemetry expected = this.CreateRemoteDependencyTelemetry();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <DependencyTelemetry, DataPlatformModel.RemoteDependencyData>(expected);
Assert.Equal(expected.Timestamp, item.Time);
Assert.Equal(expected.Sequence, item.Seq);
Assert.Equal(expected.Context.InstrumentationKey, item.IKey);
Assert.Equal(expected.Context.Tags.ToArray(), item.Tags.ToArray());
Assert.Equal(typeof(DataPlatformModel.RemoteDependencyData).Name, item.Data.BaseType);
Assert.Equal(expected.Name, item.Data.BaseData.Name);
Assert.Equal(DataPlatformModel.DataPointType.Aggregation, item.Data.BaseData.Kind);
Assert.Equal(expected.Duration.TotalMilliseconds, item.Data.BaseData.Value);
Assert.Equal(expected.DependencyKind.ToString(), item.Data.BaseData.DependencyKind.ToString());
Assert.Equal(expected.DependencyTypeName, item.Data.BaseData.DependencyTypeName);
Assert.Equal(expected.Success, item.Data.BaseData.Success);
Assert.Equal(expected.Async, item.Data.BaseData.Async);
Assert.Equal(expected.Properties.ToArray(), item.Data.BaseData.Properties.ToArray());
}
public void PageViewTelemetrySerializesToJsonCorrectly()
{
var expected = new PageViewTelemetry("My Page");
expected.Url = new Uri("http://temp.org/page1");
expected.Duration = TimeSpan.FromSeconds(123);
expected.Metrics.Add("Metric1", 30);
expected.Properties.Add("Property1", "Value1");
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <PageViewTelemetry, DataPlatformModel.PageViewData>(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.PageView);
Assert.Equal(typeof(DataPlatformModel.PageViewData).Name, item.Data.BaseType);
Assert.Equal(2, item.Data.BaseData.Ver);
Assert.Equal(expected.Name, item.Data.BaseData.Name);
Assert.Equal(expected.Duration, item.Data.BaseData.Duration);
Assert.Equal(expected.Url.ToString(), item.Data.BaseData.Url);
Assert.Equal(expected.Metrics, item.Data.BaseData.Measurements);
Assert.Equal(expected.Properties.ToArray(), item.Data.BaseData.Properties.ToArray());
}
public void RequestTelemetrySerializesToJson()
{
var expected = new RequestTelemetry();
expected.Timestamp = DateTimeOffset.Now;
expected.Id = "a1b2c3d4e5f6h7h8i9j10";
expected.Name = "GET /WebForm.aspx";
expected.Duration = TimeSpan.FromSeconds(4);
expected.ResponseCode = "200";
expected.Success = true;
expected.Url = new Uri("http://localhost/myapp/MyPage.aspx");
expected.HttpMethod = "GET";
expected.Metrics.Add("Metric1", 30);
expected.Properties.Add("userHostAddress", "::1");
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem <RequestTelemetry, DataPlatformModel.RequestData>(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.Request);
Assert.Equal(typeof(DataPlatformModel.RequestData).Name, item.Data.BaseType);
Assert.Equal(2, item.Data.BaseData.Ver);
Assert.Equal(expected.Id, item.Data.BaseData.Id);
Assert.Equal(expected.Name, item.Data.BaseData.Name);
Assert.Equal(expected.Timestamp, item.Data.BaseData.StartTime);
Assert.Equal(expected.Duration, item.Data.BaseData.Duration);
Assert.Equal(expected.Success, item.Data.BaseData.Success);
Assert.Equal(expected.ResponseCode, item.Data.BaseData.ResponseCode);
Assert.Equal(expected.Url.ToString(), item.Data.BaseData.Url.ToString(), StringComparer.OrdinalIgnoreCase);
Assert.Equal(expected.HttpMethod, item.Data.BaseData.HttpMethod);
Assert.Equal(1, item.Data.BaseData.Measurements.Count);
Assert.Equal(expected.Metrics, item.Data.BaseData.Measurements);
Assert.Equal(expected.Properties.ToArray(), item.Data.BaseData.Properties.ToArray());
}
