/// <summary>
/// Emits telemetry event once
/// </summary>
public void EmitIfNeeded()
{
if (Interlocked.CompareExchange(ref _emittedFlag, 1, 0) == 0)
{
TelemetryActivity.EmitTelemetryEvent(new TelemetryEvent(EventName));
}
}
private void NuGetPowerShellUsage_SolutionOpenHandler()
{
lock (_lock)
{
// Edge case: PMC used without solution load
if (!_vsSolutionData.SolutionLoaded && _vsSolutionData.PmcExecuteCommandCount > 0)
{
// PMC used before any solution is loaded, let's emit what we have for nugetvsinstanceclose event.
TelemetryActivity.EmitTelemetryEvent(_vsSolutionData.ToTelemetryEvent());
ClearSolutionData();
}
if (_vsSolutionData.LoadedFromPmc)
{
_vsInstanceData.PmcLoadedSolutionCount++;
}
if (_vsSolutionData.LoadedFromPmui)
{
_vsInstanceData.PmuiLoadedSolutionCount++;
}
_vsInstanceData.SolutionCount = ++_solutionCount;
_vsSolutionData.SolutionLoaded = true;
}
}
public void TelemetryTest_TelemetryActivityWithIntervalMeasure()
{
// Arrange
var secondsToWait = 5;
var telemetryService = new Mock <INuGetTelemetryService>();
TelemetryEvent telemetryEvent = null;
telemetryService.Setup(x => x.EmitTelemetryEvent(It.IsAny <TelemetryEvent>()))
.Callback <TelemetryEvent>(x => telemetryEvent = x);
TelemetryActivity.NuGetTelemetryService = telemetryService.Object;
// Act
using (var telemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationId())
{
telemetry.TelemetryEvent = new TelemetryEvent("testEvent", new Dictionary <string, object>());
telemetry.StartIntervalMeasure();
Thread.Sleep(secondsToWait * 1000);
telemetry.EndIntervalMeasure("testInterval");
}
// Assert
var value = telemetryEvent["testInterval"];
value.Should().NotBeNull();
var actualCount = Convert.ToInt32(value);
Assert.True(actualCount >= secondsToWait, $"The telemetry duration count should atleaset be {secondsToWait}");
}
private void EmitRestoreTelemetryEvent(IEnumerable <NuGetProject> projects,
bool forceRestore,
RestoreOperationSource source,
DateTimeOffset startTime,
double duration,
PackageSourceTelemetry.Totals protocolDiagnosticTotals,
IntervalTracker intervalTimingTracker)
{
var sortedProjects = projects.OrderBy(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName));
var projectIds = sortedProjects.Select(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId)).ToArray();
var restoreTelemetryEvent = new RestoreTelemetryEvent(
_nuGetProjectContext.OperationId.ToString(),
projectIds,
forceRestore,
source,
startTime,
_status,
packageCount: _packageCount,
noOpProjectsCount: _noOpProjectsCount,
upToDateProjectsCount: _upToDateProjectCount,
DateTimeOffset.Now,
duration,
isSolutionLoadRestore: _isSolutionLoadRestore,
intervalTimingTracker);
TelemetryActivity.EmitTelemetryEvent(restoreTelemetryEvent);
var sources = _sourceRepositoryProvider.PackageSourceProvider.LoadPackageSources().ToList();
var sourceEvent = SourceTelemetry.GetRestoreSourceSummaryEvent(_nuGetProjectContext.OperationId, sources, protocolDiagnosticTotals);
TelemetryActivity.EmitTelemetryEvent(sourceEvent);
}
private async Task AddVsProjectAdapterToCacheAsync(IVsProjectAdapter vsProjectAdapter)
{
_projectSystemCache.TryGetProjectNameByShortName(vsProjectAdapter.ProjectName, out var oldProjectName);
// Create the NuGet project first. If this throws we bail out and do not change the cache.
var nuGetProject = await CreateNuGetProjectAsync(vsProjectAdapter);
// Then create the project name from the project.
var newProjectName = vsProjectAdapter.ProjectNames;
// Finally, try to add the project to the cache.
var added = _projectSystemCache.AddProject(newProjectName, vsProjectAdapter, nuGetProject);
if (added && nuGetProject != null)
{
// Emit project specific telemetry as we are adding the project to the cache.
// This ensures we do not emit the events over and over while the solution is
// open.
TelemetryActivity.EmitTelemetryEvent(await VSTelemetryServiceUtility.GetProjectTelemetryEventAsync(nuGetProject));
}
if (string.IsNullOrEmpty(DefaultNuGetProjectName) ||
newProjectName.ShortName.Equals(DefaultNuGetProjectName, StringComparison.OrdinalIgnoreCase))
{
DefaultNuGetProjectName = oldProjectName != null ?
oldProjectName.CustomUniqueName :
newProjectName.ShortName;
}
}
public void Dispose_WithIndependentInterval_DoesNotClashWithNonoverlappingInterval()
{
const string independentInterval = "independentTestInterval";
const string nonOverlappingInterval = "nonOverlappingInterval";
using (var telemetry = TelemetryActivity.Create(CreateNewTelemetryEvent()))
{
telemetry.StartIntervalMeasure();
Thread.Sleep(1000);
using (telemetry.StartIndependentInterval(independentInterval))
{
Thread.Sleep(1000);
}
telemetry.EndIntervalMeasure(nonOverlappingInterval);
}
var independentIntervalValue = _telemetryEvent[independentInterval];
independentIntervalValue.Should().NotBeNull();
int independentActualCount = Convert.ToInt32(independentIntervalValue);
Assert.True(independentActualCount >= 1, $"The telemetry duration count should at least be 1 seconds.");
var overlappingIntervalValue = _telemetryEvent[nonOverlappingInterval];
overlappingIntervalValue.Should().NotBeNull();
int actualCount = Convert.ToInt32(overlappingIntervalValue);
Assert.True(actualCount >= 2, $"The telemetry duration count should at least be 2 seconds.");
}
private void EmitRestoreTelemetryEvent(IEnumerable <NuGetProject> projects,
RestoreOperationSource source,
DateTimeOffset startTime,
double duration)
{
var sortedProjects = projects.OrderBy(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName));
var projectIds = sortedProjects.Select(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId)).ToArray();
var restoreTelemetryEvent = new RestoreTelemetryEvent(
_nuGetProjectContext.OperationId.ToString(),
projectIds,
source,
startTime,
_status,
_packageCount,
_noOpProjectsCount,
DateTimeOffset.Now,
duration);
TelemetryActivity.EmitTelemetryEvent(restoreTelemetryEvent);
var sources = _sourceRepositoryProvider.PackageSourceProvider.LoadPackageSources().ToList();
var sourceEvent = SourceTelemetry.GetRestoreSourceSummaryEvent(_nuGetProjectContext.OperationId, sources);
TelemetryActivity.EmitTelemetryEvent(sourceEvent);
}
private void NuGetPowerShellUsage_SolutionCloseHandler()
{
lock (_lock)
{
TelemetryActivity.EmitTelemetryEvent(_vsSolutionData.ToTelemetryEvent());
ClearSolutionData();
}
}
public void Create_will_start_activity()
{
using (var telemetry = TelemetryActivity.Create(CreateNewTelemetryEvent()))
{
}
Assert.Equal("testEvent", _activityName);
}
public void Dispose_will_dispose_activity()
{
using (var telemetry = TelemetryActivity.Create(CreateNewTelemetryEvent()))
{
}
Assert.True(_activityDisposed);
}
public async Task UpgradeNuGetProjectAsync(INuGetUI uiService, NuGetProject nuGetProject)
{
var context = uiService.UIContext;
// Restore the project before proceeding
var solutionDirectory = context.SolutionManager.SolutionDirectory;
await context.PackageRestoreManager.RestoreMissingPackagesInSolutionAsync(solutionDirectory, uiService.ProjectContext, CancellationToken.None);
var packagesDependencyInfo = await context.PackageManager.GetInstalledPackagesDependencyInfo(nuGetProject, CancellationToken.None, includeUnresolved : true);
var upgradeInformationWindowModel = new NuGetProjectUpgradeWindowModel(nuGetProject, packagesDependencyInfo.ToList());
var result = uiService.ShowNuGetUpgradeWindow(upgradeInformationWindowModel);
if (!result)
{
// raise upgrade telemetry event with Cancelled status
var packagesCount = upgradeInformationWindowModel.UpgradeDependencyItems.Count;
var upgradeTelemetryEvent = VSTelemetryServiceUtility.GetUpgradeTelemetryEvent(
uiService.Projects,
NuGetOperationStatus.Cancelled,
packagesCount);
TelemetryActivity.EmitTelemetryEvent(upgradeTelemetryEvent);
return;
}
var progressDialogData = new ProgressDialogData(Resources.NuGetUpgrade_WaitMessage);
string backupPath;
using (var progressDialogSession = context.StartModalProgressDialog(Resources.WindowTitle_NuGetMigrator, progressDialogData, uiService))
{
backupPath = await PackagesConfigToPackageReferenceMigrator.DoUpgradeAsync(
context,
uiService,
nuGetProject,
upgradeInformationWindowModel.UpgradeDependencyItems,
upgradeInformationWindowModel.NotFoundPackages,
progressDialogSession.Progress,
progressDialogSession.UserCancellationToken);
}
if (!string.IsNullOrEmpty(backupPath))
{
var htmlLogFile = GenerateUpgradeReport(nuGetProject, backupPath, upgradeInformationWindowModel);
Process process = null;
try
{
process = Process.Start(htmlLogFile);
}
catch { }
}
}
public void RecordActivity(object telemetryActivity)
{
TelemetryActivity activity = telemetryActivity as TelemetryActivity;
_stringBuilder.AppendLine(activity.Name);
if (activity.HasProperties)
{
WriteDictionary(activity.Properties);
}
}
public void Dispose_WithEmptyParentId_EmitsNoParentId()
{
var parentId = Guid.Empty;
using (var telemetry = TelemetryActivity.Create(parentId, CreateNewTelemetryEvent()))
{
}
Assert.Null(_telemetryEvent["ParentId"]);
}
public void Dispose_Always_EmitsDuration()
{
using (var telemetry = TelemetryActivity.Create(CreateNewTelemetryEvent()))
{
Thread.Sleep(10);
}
var duration = (double)_telemetryEvent["Duration"];
Assert.InRange(duration, 0d, 10d);
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
// start timer for telemetry event
TelemetryServiceUtility.StartOrResumeTimer();
// Run Preprocess outside of JTF
Preprocess();
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await _lockService.ExecuteNuGetOperationAsync(() =>
{
SubscribeToProgressEvents();
WarnIfParametersAreNotSupported();
if (!_readFromPackagesConfig &&
!_readFromDirectPackagePath &&
_nugetVersion == null)
{
Task.Run(InstallPackageByIdAsync);
}
else
{
var identities = GetPackageIdentities();
Task.Run(() => InstallPackagesAsync(identities));
}
WaitAndLogPackageActions();
UnsubscribeFromProgressEvents();
return(Task.FromResult(true));
}, Token);
});
// stop timer for telemetry event and create action telemetry event instance
TelemetryServiceUtility.StopTimer();
var isPackageSourceMappingEnabled = PackageSourceMappingUtility.IsMappingEnabled(ConfigSettings);
var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent(
OperationId.ToString(),
new[] { Project },
NuGetOperationType.Install,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryServiceUtility.GetTimerElapsedTimeInSeconds(),
isPackageSourceMappingEnabled: isPackageSourceMappingEnabled);
// emit telemetry event along with granular level events
TelemetryActivity.EmitTelemetryEvent(actionTelemetryEvent);
}
public void Dispose_WithoutOperationIdAndWithParentId_EmitsParentIdAndNotOperationId()
{
var parentId = Guid.NewGuid();
using (var telemetry = new TelemetryActivity(parentId))
{
telemetry.TelemetryEvent = new TelemetryEvent("testEvent", new Dictionary <string, object>());
}
Assert.Null(_telemetryEvent["OperationId"]);
Assert.Equal(parentId.ToString(), _telemetryEvent["ParentId"]);
}
public void Dispose_WithOperationIdAndWithoutParentId_EmitsOperationIdAndNotParentId()
{
Guid operationId;
using (var telemetry = TelemetryActivity.Create(CreateNewTelemetryEvent()))
{
operationId = telemetry.OperationId;
}
Assert.Null(_telemetryEvent["ParentId"]);
Assert.Equal(operationId.ToString(), _telemetryEvent["OperationId"]);
}
public void Dispose_Always_EmitsEndTime()
{
using (var telemetry = TelemetryActivity.Create(CreateNewTelemetryEvent()))
{
}
var endTime = _telemetryEvent["EndTime"] as string;
Assert.NotNull(endTime);
TelemetryUtility.VerifyDateTimeFormat(endTime);
}
public void Dispose_WithOperationIdAndParentId_EmitsOperationIdAndParentId()
{
var parentId = Guid.NewGuid();
Guid operationId;
using (var telemetry = TelemetryActivity.Create(parentId, CreateNewTelemetryEvent()))
{
operationId = telemetry.OperationId;
}
Assert.Equal(parentId.ToString(), _telemetryEvent["ParentId"]);
Assert.Equal(operationId.ToString(), _telemetryEvent["OperationId"]);
}
public void Dispose_Always_EmitsStartTime()
{
using (var telemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationId())
{
telemetry.TelemetryEvent = CreateNewTelemetryEvent();
}
var startTime = _telemetryEvent["StartTime"] as string;
Assert.NotNull(startTime);
TelemetryUtility.VerifyDateTimeFormat(startTime);
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
// start timer for telemetry event
TelemetryServiceUtility.StartOrResumeTimer();
// Run Preprocess outside of JTF
Preprocess();
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await _lockService.ExecuteNuGetOperationAsync(() =>
{
SubscribeToProgressEvents();
WarnIfParametersAreNotSupported();
// Update-Package without ID specified
if (!_idSpecified)
{
Task.Run(UpdateOrReinstallAllPackagesAsync);
}
// Update-Package with Id specified
else
{
Task.Run(UpdateOrReinstallSinglePackageAsync);
}
WaitAndLogPackageActions();
UnsubscribeFromProgressEvents();
return(Task.FromResult(true));
}, Token);
});
// stop timer for telemetry event and create action telemetry event instance
TelemetryServiceUtility.StopTimer();
var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent(
OperationId.ToString(),
new[] { Project },
NuGetOperationType.Update,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryServiceUtility.GetTimerElapsedTimeInSeconds());
// emit telemetry event along with granular level events
TelemetryActivity.EmitTelemetryEvent(actionTelemetryEvent);
}
private void EmitRestoreTelemetryEvent(IEnumerable <NuGetProject> projects,
bool forceRestore,
RestoreOperationSource source,
DateTimeOffset startTime,
double duration,
PackageSourceTelemetry.Totals protocolDiagnosticTotals,
IntervalTracker intervalTimingTracker)
{
var sortedProjects = projects.OrderBy(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.UniqueName));
var projectIds = sortedProjects.Select(
project => project.GetMetadata <string>(NuGetProjectMetadataKeys.ProjectId)).ToArray();
var projectDictionary = sortedProjects
.GroupBy(x => x.ProjectStyle)
.ToDictionary(x => x.Key, y => y.Count());
var packageSourceMapping = PackageSourceMapping.GetPackageSourceMapping(_settings);
bool isPackageSourceMappingEnabled = packageSourceMapping?.IsEnabled ?? false;
var restoreTelemetryEvent = new RestoreTelemetryEvent(
_nuGetProjectContext.OperationId.ToString(),
projectIds,
forceRestore,
source,
startTime,
_status,
packageCount: _packageCount,
noOpProjectsCount: _noOpProjectsCount,
upToDateProjectsCount: _upToDateProjectCount,
unknownProjectsCount: projectDictionary.GetValueOrDefault(ProjectStyle.Unknown, 0), // appears in DependencyGraphRestoreUtility
projectJsonProjectsCount: projectDictionary.GetValueOrDefault(ProjectStyle.ProjectJson, 0),
packageReferenceProjectsCount: projectDictionary.GetValueOrDefault(ProjectStyle.PackageReference, 0),
legacyPackageReferenceProjectsCount: sortedProjects.Where(x => x.ProjectStyle == ProjectStyle.PackageReference && x is LegacyPackageReferenceProject).Count(),
cpsPackageReferenceProjectsCount: sortedProjects.Where(x => x.ProjectStyle == ProjectStyle.PackageReference && x is CpsPackageReferenceProject).Count(),
dotnetCliToolProjectsCount: projectDictionary.GetValueOrDefault(ProjectStyle.DotnetCliTool, 0), // appears in DependencyGraphRestoreUtility
packagesConfigProjectsCount: projectDictionary.GetValueOrDefault(ProjectStyle.PackagesConfig, 0),
DateTimeOffset.Now,
duration,
_trackingData,
intervalTimingTracker,
isPackageSourceMappingEnabled);
TelemetryActivity.EmitTelemetryEvent(restoreTelemetryEvent);
var sources = _sourceRepositoryProvider.PackageSourceProvider.LoadPackageSources().ToList();
var sourceEvent = SourceTelemetry.GetRestoreSourceSummaryEvent(_nuGetProjectContext.OperationId, sources, protocolDiagnosticTotals);
TelemetryActivity.EmitTelemetryEvent(sourceEvent);
}
private void NuGetPowerShellUsage_VSInstanseCloseHandler()
{
lock (_lock)
{
// Edge case: PMC used without solution load
if (!_vsSolutionData.SolutionLoaded && _vsSolutionData.PmcExecuteCommandCount > 0)
{
// PMC used before any solution is loaded, let's emit what we have for nugetvsinstanceclose event.
TelemetryActivity.EmitTelemetryEvent(_vsSolutionData.ToTelemetryEvent());
}
// Emit VS Instance telemetry
TelemetryActivity.EmitTelemetryEvent(_vsInstanceData.ToTelemetryEvent());
}
}
/// <summary>
/// Handles Hyperlink controls inside this DetailControl class associated with
/// <see cref="PackageManagerControlCommands.OpenExternalLink" />
/// </summary>
/// <param name="sender">A Hyperlink control</param>
/// <param name="e">Command arguments</param>
private void ExecuteOpenExternalLink(object sender, ExecutedRoutedEventArgs e)
{
var hyperlink = e.OriginalSource as Hyperlink;
if (hyperlink != null && hyperlink.NavigateUri != null)
{
Control.Model.UIController.LaunchExternalLink(hyperlink.NavigateUri);
e.Handled = true;
if (e.Parameter is not null and HyperlinkType hyperlinkType)
{
var evt = new HyperlinkClickedTelemetryEvent(hyperlinkType, UIUtility.ToContractsItemFilter(Control.ActiveFilter), Control.Model.IsSolution);
TelemetryActivity.EmitTelemetryEvent(evt);
}
}
}
public static void EmitException(string className, string methodName, Exception exception)
{
if (className == null)
{
throw new ArgumentNullException(nameof(className));
}
if (methodName == null)
{
throw new ArgumentNullException(nameof(methodName));
}
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
TelemetryEvent ToTelemetryEvent(Exception e, string name)
{
TelemetryEvent te = new TelemetryEvent(name);
te["Message"] = e.Message;
te["ExceptionType"] = e.GetType().FullName;
te["StackTrace"] = e.StackTrace;
if (e is AggregateException aggregateException)
{
var exceptions =
aggregateException.InnerExceptions
.Select(ie => ToTelemetryEvent(ie, name: null))
.ToList();
te.ComplexData["InnerExceptions"] = exceptions;
}
else if (e.InnerException != null)
{
var inner = ToTelemetryEvent(e.InnerException, name: null);
te.ComplexData["InnerException"] = inner;
}
return(te);
}
TelemetryEvent telemetryEvent = ToTelemetryEvent(exception, $"errors/{className}.{methodName}");
TelemetryActivity.EmitTelemetryEvent(telemetryEvent);
}
public void EmitTelemetryEvent(Guid parentId)
{
var telemetryEvent = new TelemetryEvent(PackagePreFetcherInformation);
telemetryEvent["DownloadStartTime"] = _downloadStartTime;
telemetryEvent["PackageFetchTime"] = _packageFetchTime;
telemetryEvent["TaskReturnTime"] = _taskReturnTime;
var packageId = CryptoHashUtility.GenerateUniqueToken(Package.ToString());
telemetryEvent.AddPiiData("PackageId", Package.ToString());
if (parentId != Guid.Empty)
{
telemetryEvent["ParentId"] = parentId.ToString();
}
TelemetryActivity.EmitTelemetryEvent(telemetryEvent);
}
public void Dispose_WithIntervalMeasure_EmitsIntervalMeasure()
{
const string measureName = "testInterval";
var secondsToWait = 1;
using (var telemetry = TelemetryActivity.Create(CreateNewTelemetryEvent()))
{
telemetry.StartIntervalMeasure();
Thread.Sleep(secondsToWait * 1000);
telemetry.EndIntervalMeasure(measureName);
}
var value = _telemetryEvent[measureName];
value.Should().NotBeNull();
var actualCount = Convert.ToInt32(value);
Assert.True(actualCount >= secondsToWait, $"The telemetry duration count should at least be {secondsToWait} seconds.");
}
public void TelemetryTest_TelemetryActivityWithEmptyParentId()
{
// Arrange
var telemetryService = new Mock <INuGetTelemetryService>();
TelemetryEvent telemetryEvent = null;
var parentId = Guid.Empty;
telemetryService.Setup(x => x.EmitTelemetryEvent(It.IsAny <TelemetryEvent>()))
.Callback <TelemetryEvent>(x => telemetryEvent = x);
TelemetryActivity.NuGetTelemetryService = telemetryService.Object;
// Act
using (var telemetry = new TelemetryActivity(parentId))
{
telemetry.TelemetryEvent = new TelemetryEvent("testEvent", new Dictionary <string, object>());
}
// Assert
Assert.Null(telemetryEvent["ParentId"]);
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
_packageCount = 1;
var stopWatch = Stopwatch.StartNew();
// Run Preprocess outside of JTF
Preprocess();
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await _lockService.ExecuteNuGetOperationAsync(() =>
{
SubscribeToProgressEvents();
Task.Run(UninstallPackageAsync);
WaitAndLogPackageActions();
UnsubscribeFromProgressEvents();
return(Task.FromResult(true));
}, Token);
});
stopWatch.Stop();
var isPackageSourceMappingEnabled = PackageSourceMappingUtility.IsMappingEnabled(ConfigSettings);
var actionTelemetryEvent = VSTelemetryServiceUtility.GetActionTelemetryEvent(
OperationId.ToString(),
new[] { Project },
NuGetOperationType.Uninstall,
OperationSource.PMC,
startTime,
_status,
_packageCount,
stopWatch.Elapsed.TotalSeconds,
isPackageSourceMappingEnabled: isPackageSourceMappingEnabled);
// emit telemetry event along with granular level events
TelemetryActivity.EmitTelemetryEvent(actionTelemetryEvent);
}
public void SendTelemetry()
{
var parentId = _parentId.ToString();
foreach (var kvp in _data)
{
Data data = kvp.Value;
string source = kvp.Key;
if (!_sources.TryGetValue(kvp.Key, out PackageSource packageSource))
{
packageSource = null;
}
var telemetry = ToTelemetry(data, source, packageSource, parentId);
if (telemetry != null)
{
TelemetryActivity.EmitTelemetryEvent(telemetry);
}
}
}
public void LogBlockStart(FunctionId functionId, LogMessage logMessage, int uniquePairId, CancellationToken cancellationToken)
{
var eventName = functionId.GetEventName();
_pendingActivities[uniquePairId] = new TelemetryActivity(_service, eventName, startCodeMarker: 0, endCodeMarker: 0, codeMarkerData: null, parentCorrelationId: Guid.Empty);
}
