public void SerializeWritesNullValuesAsExpectedByEndpoint()
{
EventTelemetry original = new EventTelemetry();
original.Name = null;
((ITelemetry)original).Sanitize();
var item = TelemetryItemTestHelper.SerializeDeserializeTelemetryItem<EventTelemetry, DataPlatformModel.EventData>(original);
Assert.Equal(2, item.Data.BaseData.Ver);
}
private void AssertSyntheticSourceIsSet(string userAgent)
{
var eventTelemetry = new EventTelemetry("name");
var source = new TestableSyntheticUserAgentTelemetryInitializer(new Dictionary <string, string>
{
{ "User-Agent", userAgent }
});
source.Filters = this.botSubstrings;
source.Initialize(eventTelemetry);
Assert.AreEqual("Bot", eventTelemetry.Context.Operation.SyntheticSource, "Incorrect result for " + userAgent);
}
private void TrackEventWithParameters(string name, DbConnection connection, Guid connectionId,
Dictionary <string, string> parameters)
{
StartOperation(connection as Npgsql.NpgsqlConnection, connectionId);
parameters.Add("ConnectionId", connectionId.ToString());
var eventTelemetry = new EventTelemetry($"Database Event: {name}");
foreach (var(key, value) in parameters)
{
eventTelemetry.Properties.Add(key, value);
}
_telemetryClient.TrackEvent(eventTelemetry);
}
public void InitializeDoesNotThrowWhenHttpContextIsNull()
{
// Arrange
HttpContext.Current = null;
var source = new AuthenticatedUserIdTelemetryInitializer();
// Act
var eventTelemetry = new EventTelemetry("name");
source.Initialize(eventTelemetry);
// Assert
Assert.AreEqual("name", eventTelemetry.Name);
}
private static void TrackRequest(Request request)
{
TelemetryClient telemetryClient = new TelemetryClient(
new TelemetryConfiguration
{
InstrumentationKey = ConfigurationManager.AppSettings["APPINSIGHTS_INSTRUMENTATIONKEY"]
}
);
var trackingEvent = new EventTelemetry("Complete");
trackingEvent.Context.Operation.Id = request.Id;
telemetryClient.TrackEvent(trackingEvent);
}
public void AzureRoleEnvironmentTelemetryInitializerDoesNotOverrideNodeName()
{
var telemetryItem = new EventTelemetry();
AzureRoleEnvironmentTelemetryInitializer initializer = new AzureRoleEnvironmentTelemetryInitializer();
AzureRoleEnvironmentContextReader.BaseDirectory = ServiceRuntimeHelper.TestWithServiceRuntimePath;
AzureRoleEnvironmentContextReader.Instance = null;
ServiceRuntimeHelper.IsAvailable = true;
telemetryItem.Context.GetInternalContext().NodeName = "Test";
initializer.Initialize(telemetryItem);
Assert.Equal("Test", telemetryItem.Context.GetInternalContext().NodeName);
}
internal static void AddGuidelinesToTelemetry(EventTelemetry eventTelemetry, IEnumerable <Guideline> guidelines)
{
var telemetryProperties = eventTelemetry.Properties;
var count = 0;
foreach (var guideline in guidelines)
{
telemetryProperties.Add("guide" + count.ToString(InvariantCulture), guideline.ToString());
count++;
}
eventTelemetry.Metrics.Add("Count", count);
}
public void UserSessionSourceAreNotSetIfRunIsNotSet()
{
var eventTelemetry = new EventTelemetry("name");
var source = new TestableWebTestTelemetryInitializer(new Dictionary <string, string>
{
{ "SyntheticTest-Location", "LOCATION" },
});
source.Initialize(eventTelemetry);
Assert.IsNull(eventTelemetry.Context.User.Id);
Assert.IsNull(eventTelemetry.Context.Session.Id);
Assert.IsNull(eventTelemetry.Context.Operation.SyntheticSource);
}
public void Test_EventTelemetry_OperationIsPoPulated()
{
const string correlationVector = "SOMEIDHERE.1.3";
var tEvent = new EventTelemetry();
var bbEvent = new BbTelemetryEvent
{
CorrelationVector = correlationVector
};
tEvent.SetCorrelation(bbEvent);
tEvent.Context.Operation.CorrelationVector.Should().Be(correlationVector);
tEvent.Context.Operation.Id.Should().Be(correlationVector);
}
public void InitializeSetsOperationIdToRequestOperationIdAndParentIdToRequestId()
{
var requestTelemetry = new RequestTelemetry();
requestTelemetry.Context.Operation.Id = "ABC";
var initializer = CreateInitializer(requestTelemetry);
var telemetry = new EventTelemetry();
initializer.Initialize(telemetry);
Assert.Equal("ABC", telemetry.Context.Operation.Id);
Assert.Equal(requestTelemetry.Id, telemetry.Context.Operation.ParentId);
}
public void AzureWebAppRoleEnvironmentTelemetryInitializerEmptyVariable()
{
Environment.SetEnvironmentVariable("WEBSITE_HOSTNAME", null);
var telemetryItem = new EventTelemetry();
var initializer = new AzureWebAppRoleEnvironmentTelemetryInitializer();
initializer.Initialize(telemetryItem);
Assert.Null(telemetryItem.Context.Cloud.RoleName);
Assert.Null(telemetryItem.Context.Cloud.RoleInstance);
Assert.Null(telemetryItem.Context.GetInternalContext().NodeName);
}
public void ClientIpIsCopiedFromRequestIfPresent()
{
const String clientIp = "10.12.32.12";
var context = new MockOperationContext();
context.Request.Context.Location.Ip = clientIp;
var initializer = new ClientIpTelemetryInitializer();
var telemetry = new EventTelemetry();
initializer.Initialize(telemetry, context);
Assert.AreEqual(clientIp, telemetry.Context.Location.Ip);
}
public void ChannelLogsResponseBodyFromTransmissionWhenVerboseEnabled()
{
var expectedResponseContents = "this is the expected response";
using (var localServer = new LocalInProcHttpServer(Localurl))
{
localServer.ServerLogic = async(ctx) =>
{
await ctx.Response.WriteAsync(expectedResponseContents);
};
var channel = new ServerTelemetryChannel
{
DeveloperMode = true,
EndpointAddress = Localurl
};
var config = new TelemetryConfiguration("dummy")
{
TelemetryChannel = channel
};
channel.Initialize(config);
using (var listener = new TestEventListener())
{
listener.EnableEvents(TelemetryChannelEventSource.Log, EventLevel.LogAlways,
(EventKeywords)AllKeywords);
// Enable CoreEventSource as Transmission logic is in base sdk.
// and it'll parse response only on Verbose enabled.
using (var listenerCore = new TestEventListener())
{
listener.EnableEvents(CoreEventSource.Log, EventLevel.LogAlways,
(EventKeywords)AllKeywords);
// ACT
var telemetry = new EventTelemetry("test event name");
telemetry.Context.InstrumentationKey = "dummy";
channel.Send(telemetry);
Thread.Sleep(SleepInMilliseconds);
}
// Assert:
var allTraces = listener.Messages.ToList();
var traces = allTraces.Where(item => item.EventId == 70).ToList();
Assert.AreEqual(1, traces.Count);
Assert.IsTrue(traces[0].Payload[1].ToString().Contains(expectedResponseContents));
}
}
}
private void EndCore(string message, bool success)
{
if (!disposed)
{
disposed = true;
CreateTraceWithOpContext(message);
var eventTelemetry = new EventTelemetry($"{operationName}-{(success ? "Succeded" : "Failed")}");
if (!string.IsNullOrWhiteSpace(message))
{
eventTelemetry.Properties.Add(success ? "AdditionalMessage" : "ErrorMessage", message);
}
client.TrackEvent(eventTelemetry);
}
}
public void SyntheticSourceIsNotSetIfNoMatch()
{
var eventTelemetry = new EventTelemetry("name");
var source = new TestableSyntheticUserAgentTelemetryInitializer(new Dictionary <string, string>
{
{ "User-Agent", "Yan23232dexBooot" }
});
source.Filters = this.botSubstrings;
source.Initialize(eventTelemetry);
Assert.IsNull(eventTelemetry.Context.Operation.SyntheticSource);
}
public void Ensure_NullCorrelation_DoesntPopulate()
{
const string correlationVector = null;
var tEvent = new EventTelemetry();
var bbEvent = new BbTelemetryEvent
{
CorrelationVector = correlationVector
};
tEvent.SetCorrelation(bbEvent);
tEvent.Context.Operation.CorrelationVector.Should().BeNull();
tEvent.Context.Operation.Id.Should().BeNull();
}
public void SessionIdIsSetToRunId()
{
var eventTelemetry = new EventTelemetry("name");
var source = new TestableWebTestTelemetryInitializer(new Dictionary <string, string>
{
{ "SyntheticTest-Location", "LOCATION" },
{ "synthetictest-runid", "ID" },
});
source.Initialize(eventTelemetry);
Assert.AreEqual("ID", eventTelemetry.Context.Session.Id);
}
/// <summary>
/// Send an <see cref="T:Coding4Fun.VisualStudio.ApplicationInsights.DataContracts.EventTelemetry" /> for display in Diagnostic Search and aggregation in Metrics Explorer.
/// </summary>
/// <param name="eventName">A name for the event.</param>
/// <param name="properties">Named string values you can use to search and classify events.</param>
/// <param name="metrics">Measurements associated with this event.</param>
public void TrackEvent(string eventName, IDictionary <string, string> properties = null, IDictionary <string, double> metrics = null)
{
EventTelemetry eventTelemetry = new EventTelemetry(eventName);
if (properties != null && properties.Count > 0)
{
Utils.CopyDictionary(properties, eventTelemetry.Context.Properties);
}
if (metrics != null && metrics.Count > 0)
{
Utils.CopyDictionary(metrics, eventTelemetry.Metrics);
}
TrackEvent(eventTelemetry);
}
public void TrackTestExecution(string projectTrackInfo)
{
bool isDebug = IsDebugRun();
try
{
if (!isDebug)
{
projectTrackInfo = $"{projectTrackInfo} Framework";
var assemblyFacade = new AssemblyFacade();
var callingAssemblies = assemblyFacade.GetAssembliesCallChain();
var testProjectAssembly = callingAssemblies[3];
if (callingAssemblies.Any(x => x.FullName.Contains("SpecFlow")))
{
projectTrackInfo = $"{projectTrackInfo} SpecFlow";
}
if (testProjectAssembly.FullName.Contains("GettingStarted"))
{
projectTrackInfo = $"{projectTrackInfo} GettingStarted";
}
var testInfoProvider = new TestInfoProvider();
EventTelemetry eventTelemetry = default;
int mstestTestsCount = testInfoProvider.CountBellatrixTests(testProjectAssembly, _msTestClassAttributeName, _msTestTestAttributeName);
int nunitTestsCount = testInfoProvider.CountBellatrixTests(testProjectAssembly, _nunitTestFixtureAttributeName, _nunitTestAttributeName);
if (mstestTestsCount > 0)
{
eventTelemetry = new EventTelemetry();
eventTelemetry.Name = "MSTest Test Run";
eventTelemetry.Metrics.Add(projectTrackInfo, mstestTestsCount);
}
if (nunitTestsCount > 0)
{
eventTelemetry = new EventTelemetry();
eventTelemetry.Name = "NUnit Test Run";
eventTelemetry.Metrics.Add(projectTrackInfo, nunitTestsCount);
}
TelemetryService.TrackEvent(eventTelemetry, isDebug);
}
}
catch (Exception ex)
{
TelemetryService.TrackException(ex, isDebug);
}
}
public void TransmissionProcessorStartsChannelSanitizationAfterDebugOutputSanitization()
{
var debugOutput = new StubDebugOutput
{
OnWriteLine = message =>
{
// do nothing
},
OnIsAttached = () => true,
};
PlatformSingleton.Current = new StubPlatform {
OnGetDebugOutput = () => debugOutput
};
var channel = new StubTelemetryChannel {
OnSend = t => new Task(() =>
{
((ITelemetry)t).Sanitize();
}).Start()
};
var configuration = new TelemetryConfiguration {
InstrumentationKey = "Test key", TelemetryChannel = channel
};
var client = new TelemetryClient(configuration);
var transmissionProcessor = new TransmissionProcessor(configuration);
const int ItemsToGenerate = 100;
Random random = new Random();
for (int i = 0; i < ItemsToGenerate; i++)
{
EventTelemetry telemetry = new EventTelemetry();
int len = random.Next(50);
for (int j = 0; j < len; j++)
{
telemetry.Properties.Add(j.ToString(), j.ToString());
}
transmissionProcessor.Process(telemetry);
}
// There were a bug that causes Sanitize call from DebugOutput tracer conflict with Sanitize call from Channel
// If no exceptions here - everything fine
Assert.True(true);
}
public override ITelemetry ToTelemetry()
{
var eventTelementry = new EventTelemetry {
Name = GetType().Name
};
eventTelementry.Properties["BatchId"] = BatchId.ToString();
eventTelementry.Properties["RecordId"] = RecordId.ToString();
eventTelementry.Properties["Failed"] = Failed.ToString();
eventTelementry.Properties["EventType"] = EventType.ToString();
eventTelementry.Properties["Message"] = Message;
return(eventTelementry);
}
public static void TraceEvent(string eventTitle, IDictionary <string, string> properties)
{
var telemetryEvent = new EventTelemetry(eventTitle);
if (properties != null)
{
foreach (KeyValuePair <string, string> entry in properties)
{
telemetryEvent.Properties.Add(entry.Key, entry.Value);
}
}
TelemetryClient.TrackEvent(telemetryEvent);
}
public void InitializeDoesNotSetIsFirstIfTelemetryHasId()
{
var telemetry = new EventTelemetry("name");
var source = new TestableSessionTelemetryInitializer();
var context = source.FakeContext.CreateRequestTelemetryPrivate();
context.Context.Session.IsFirst = true;
telemetry.Context.Session.IsFirst = false;
telemetry.Context.Session.Id = "5";
source.Initialize(telemetry);
Assert.IsTrue(telemetry.Context.Session.IsFirst.HasValue);
Assert.IsFalse(telemetry.Context.Session.IsFirst.Value);
}
private void Staging_SynchronizeTask_Before(object sender, StagingTaskEventArgs e)
{
var telemetry = new EventTelemetry("Staging Synchronization Task Starting")
{
Timestamp = DateTimeOffset.UtcNow
};
telemetry.Properties[nameof(e.Task.TaskDocumentID)] = e.Task.TaskDocumentID.ToString() ?? string.Empty;
telemetry.Properties[nameof(e.Task.TaskID)] = e.Task.TaskID.ToString() ?? string.Empty;
telemetry.Properties[nameof(e.Task.TaskSiteID)] = e.Task.TaskSiteID.ToString() ?? string.Empty;
telemetry.Properties[nameof(e.Task.TaskTitle)] = e.Task.TaskTitle ?? string.Empty;
telemetry.Properties[nameof(e.Task.TaskServers)] = e.Task.TaskServers ?? string.Empty;
_telemetryService.TrackEvent(telemetry);
}
public void InitializeSetsRoleInstance()
{
PlatformSingleton.Current = new StubPlatform {
OnGetMachineName = () => "TestMachine"
};
EventTelemetry telemetry = new EventTelemetry("TestEvent");
new TelemetryClient().Initialize(telemetry);
Assert.Equal("TestMachine", telemetry.Context.Cloud.RoleInstance);
Assert.Null(telemetry.Context.Internal.NodeName);
PlatformSingleton.Current = null;
}
public void UserAgentIsCopiedFromRequestIfPresent()
{
var context = new MockOperationContext();
context.EndpointUri = new Uri("http://localhost/Service1.svc");
context.OperationName = "GetData";
context.Request.Context.User.UserAgent = "MyUserAgent";
var initializer = new UserAgentTelemetryInitializer();
var telemetry = new EventTelemetry();
initializer.Initialize(telemetry, context);
Assert.AreEqual(context.Request.Context.User.UserAgent, telemetry.Context.User.UserAgent);
}
private void TrackShowEvent(AdminInputModel input, LiveShowDetails liveShowDetails)
{
if (_telemetry.IsEnabled())
{
var showStarted = string.IsNullOrEmpty(liveShowDetails.LiveShowEmbedUrl) && !string.IsNullOrEmpty(input.LiveShowEmbedUrl);
var showEnded = !string.IsNullOrEmpty(liveShowDetails.LiveShowEmbedUrl) && string.IsNullOrEmpty(input.LiveShowEmbedUrl);
if (showStarted || showEnded)
{
var showEvent = new EventTelemetry(showStarted ? "Show Started" : "Show Ended");
showEvent.Properties.Add("Show Embed URL", showStarted ? input.LiveShowEmbedUrl : liveShowDetails.LiveShowEmbedUrl);
_telemetry.TrackEvent(showEvent);
}
}
}
public void TrackDoesNotOverrideSdkVersion()
{
var configuration = new TelemetryConfiguration {
TelemetryChannel = new StubTelemetryChannel(), InstrumentationKey = Guid.NewGuid().ToString()
};
var client = new TelemetryClient(configuration);
client.Context.InstrumentationKey = "Test";
EventTelemetry eventTelemetry = new EventTelemetry("test");
eventTelemetry.Context.Internal.SdkVersion = "test";
client.Track(eventTelemetry);
Assert.Equal("test", eventTelemetry.Context.Internal.SdkVersion);
}
public void SanitizesTelemetryContextGlobalProperties()
{
var addedValueWithSizeAboveLimit = new string('V', Property.MaxValueLength + 1);
var expectedValueWithSizeWithinLimit = new string('V', Property.MaxValueLength);
EventTelemetry t = new EventTelemetry("myevent");
t.Context.GlobalProperties.Add("mykey", addedValueWithSizeAboveLimit);
string exceptionAsJson = JsonSerializer.SerializeAsString(t);
JObject obj = JsonConvert.DeserializeObject <JObject>(exceptionAsJson);
Assert.AreEqual(expectedValueWithSizeWithinLimit, obj["data"]["baseData"]["properties"]["mykey"]);
}
public void AzureRoleEnvironmentTelemetryInitializerSetsTelemetryContextPropertiesWhenRoleEnvironmentIsNotAvailable()
{
var telemetryItem = new EventTelemetry();
AzureRoleEnvironmentTelemetryInitializer initializer = new AzureRoleEnvironmentTelemetryInitializer();
AzureRoleEnvironmentContextReader.BaseDirectory = ServiceRuntimeHelper.TestWithServiceRuntimePath;
AzureRoleEnvironmentContextReader.Instance = null;
ServiceRuntimeHelper.IsAvailable = false;
initializer.Initialize(telemetryItem);
ServiceRuntimeHelper.IsAvailable = true;
Assert.Null(telemetryItem.Context.Cloud.RoleName);
Assert.Null(telemetryItem.Context.Cloud.RoleInstance);
}
public void OnSignFile(string file, string toolName)
{
var evt = new EventTelemetry
{
Name = "Sign File",
Properties =
{
{ "FullName", GetRelativeDirectoryUnderTemp(file) },
{ "FileName", Path.GetFileName(file) },
{ "ToolName", toolName }
}
};
telemetryClient.TrackEvent(evt);
}
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 ReleaseQueryInfo Index([System.Web.Http.ModelBinding.ModelBinder(typeof(VersionCheckDetailsApiModelBinderProvider))] VersionCheckDetails details, bool withDetails = false)
{
string userId = null;
if (HttpContext.Current.Request.Cookies["ai_user"] == null)
{
userId = Guid.NewGuid().ToString();
var c = new HttpCookie("ai_user", userId + "|" + DateTime.Now.ToString("G"));
c.Expires = DateTime.MaxValue;
c.Path = "/";
HttpContext.Current.Response.Cookies.Set(c);
}
foreach (var package in details.Packages)
{
EventTelemetry evt = new EventTelemetry();
evt.Name = "Check " + package.Name;
if (!string.IsNullOrEmpty(userId))
{
evt.Context.User.Id = userId;
}
evt.Properties.Add("Package", package.Name);
evt.Properties.Add ("Version", package.Version);
if (HttpContext.Current.Request.UrlReferrer != null)
{
evt.Properties.Add("urlReferrer", HttpContext.Current.Request.UrlReferrer.ToString());
}
telemetry.TrackEvent(evt);
}
var service = PackageSettings.Settings.ReleaseQueryService;
var result = service.GetReleaseInfo(details, withDetails);
result.ViewLink = GenerateViewUri(Url.Request.RequestUri, result);
return result;
}
public void SanitizeWillTrimAppropriateFields()
{
EventTelemetry telemetry = new EventTelemetry();
telemetry.Name = new string('Z', Property.MaxNameLength + 1);
telemetry.Properties.Add(new string('X', Property.MaxDictionaryNameLength) + 'X', new string('X', Property.MaxValueLength + 1));
telemetry.Properties.Add(new string('X', Property.MaxDictionaryNameLength) + 'Y', new string('X', Property.MaxValueLength + 1));
telemetry.Metrics.Add(new string('Y', Property.MaxDictionaryNameLength) + 'X', 42.0);
telemetry.Metrics.Add(new string('Y', Property.MaxDictionaryNameLength) + 'Y', 42.0);
((ITelemetry)telemetry).Sanitize();
Assert.Equal(new string('Z', Property.MaxNameLength), telemetry.Name);
Assert.Equal(2, telemetry.Properties.Count);
Assert.Equal(new string('X', Property.MaxDictionaryNameLength), telemetry.Properties.Keys.ToArray()[0]);
Assert.Equal(new string('X', Property.MaxValueLength), telemetry.Properties.Values.ToArray()[0]);
Assert.Equal(new string('X', Property.MaxDictionaryNameLength - 3) + "001", telemetry.Properties.Keys.ToArray()[1]);
Assert.Equal(new string('X', Property.MaxValueLength), telemetry.Properties.Values.ToArray()[1]);
Assert.Equal(2, telemetry.Metrics.Count);
Assert.Equal(new string('Y', Property.MaxDictionaryNameLength), telemetry.Metrics.Keys.ToArray()[0]);
Assert.Equal(new string('Y', Property.MaxDictionaryNameLength - 3) + "001", telemetry.Metrics.Keys.ToArray()[1]);
}
private static void SerializeEventTelemetry(EventTelemetry eventTelemetry, JsonWriter writer)
{
writer.WriteStartObject();
eventTelemetry.WriteTelemetryName(writer, EventTelemetry.TelemetryName);
eventTelemetry.WriteEnvelopeProperties(writer);
writer.WritePropertyName("data");
{
writer.WriteStartObject();
writer.WriteProperty("baseType", eventTelemetry.BaseType);
writer.WritePropertyName("baseData");
{
writer.WriteStartObject();
writer.WriteProperty("ver", eventTelemetry.Data.ver);
writer.WriteProperty("name", eventTelemetry.Data.name);
writer.WriteProperty("measurements", eventTelemetry.Data.measurements);
writer.WriteProperty("properties", eventTelemetry.Data.properties);
writer.WriteEndObject();
}
writer.WriteEndObject();
}
writer.WriteEndObject();
}
/// <summary>
/// Send an event telemetry for display in Diagnostic Search and aggregation in Metrics Explorer.
/// </summary>
/// <param name="eventName">A name for the event.</param>
/// <param name="properties">Named string values you can use to search and classify events.</param>
/// <param name="metrics">Measurements associated with this event.</param>
public void TrackEvent(string eventName, IDictionary<string, string> properties = null, IDictionary<string, double> metrics = null)
{
var telemetry = new EventTelemetry(eventName);
if (properties != null && properties.Count > 0)
{
Utils.CopyDictionary(properties, telemetry.Context.Properties);
}
if (metrics != null && metrics.Count > 0)
{
Utils.CopyDictionary(metrics, telemetry.Metrics);
}
this.TrackEvent(telemetry);
}
/// <summary>
/// Send an <see cref="EventTelemetry"/> for display in Diagnostic Search and aggregation in Metrics Explorer.
/// </summary>
/// <param name="telemetry">An event log item.</param>
public void TrackEvent(EventTelemetry telemetry)
{
if (telemetry != null)
{
this.Track(telemetry);
}
}
public void EventTelemetrySuppliesParameterizedConstructorToSimplifyCreatingEventWithGivenNameInAdvancedScenarios()
{
var @event = new EventTelemetry("Test Name");
Assert.Equal("Test Name", @event.Name);
}
public void MetricsReturnsEmptyDictionaryByDefaultToPreventNullReferenceExceptions()
{
var @event = new EventTelemetry();
IDictionary<string, double> metrics = @event.Metrics;
Assert.NotNull(metrics);
}
public void SanitizePopulatesNameWithErrorBecauseItIsRequiredByEndpoint()
{
var telemetry = new EventTelemetry { Name = null };
((ITelemetry)telemetry).Sanitize();
Assert.Contains("name", telemetry.Name, StringComparison.OrdinalIgnoreCase);
Assert.Contains("required", telemetry.Name, StringComparison.OrdinalIgnoreCase);
}
public void EventTelemetryReturnsNonNullContext()
{
EventTelemetry item = new EventTelemetry();
Assert.NotNull(item.Context);
}
