protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
// Set to log telemetry granular events for this update operation
TelemetryService = new TelemetryServiceHelper();
// start timer for telemetry event
TelemetryUtility.StartorResumeTimer();
using (var lck = _lockService.AcquireLock())
{
Preprocess();
SubscribeToProgressEvents();
PerformPackageUpdatesOrReinstalls();
UnsubscribeFromProgressEvents();
}
// stop timer for telemetry event and create action telemetry event instance
TelemetryUtility.StopTimer();
var actionTelemetryEvent = TelemetryUtility.GetActionTelemetryEvent(
new[] { Project },
NuGetOperationType.Update,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryUtility.GetTimerElapsedTimeInSeconds());
// emit telemetry event along with granular level for update operation
ActionsTelemetryService.Instance.EmitActionEvent(actionTelemetryEvent, TelemetryService.TelemetryEvents);
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
_packageCount = 1;
// Enable granular level events for this uninstall operation
TelemetryService = new TelemetryServiceHelper();
TelemetryUtility.StartorResumeTimer();
using (var lck = _lockService.AcquireLock())
{
Preprocess();
SubscribeToProgressEvents();
Task.Run(UninstallPackageAsync);
WaitAndLogPackageActions();
UnsubscribeFromProgressEvents();
}
TelemetryUtility.StopTimer();
var actionTelemetryEvent = TelemetryUtility.GetActionTelemetryEvent(
new[] { Project },
NuGetOperationType.Uninstall,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryUtility.GetTimerElapsedTimeInSeconds());
// emit telemetry event with granular level events
ActionsTelemetryService.Instance.EmitActionEvent(actionTelemetryEvent, TelemetryService.TelemetryEvents);
}
public static void EmitEvent(TelemetryServiceHelper telemetryHelper, string eventName, double duration)
{
if (telemetryHelper != null)
{
telemetryHelper.AddTelemetryEvent(eventName, duration);
}
}
public static void EmitEventAndRestartTimer(TelemetryServiceHelper telemetryHelper, string eventName)
{
if (telemetryHelper != null)
{
EmitEvent(telemetryHelper, eventName);
telemetryHelper.StartorResumeTimer();
}
}
public static void EmitEvent(TelemetryServiceHelper telemetryHelper, string eventName)
{
if (telemetryHelper != null)
{
telemetryHelper.StopTimer();
telemetryHelper.AddTelemetryEvent(eventName);
}
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
// Set to log telemetry granular events for this update operation
TelemetryService = new TelemetryServiceHelper();
// start timer for telemetry event
TelemetryUtility.StartorResumeTimer();
// Run Preprocess outside of JTF
Preprocess();
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await _lockService.ExecuteNuGetOperationAsync(() =>
{
SubscribeToProgressEvents();
// 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
TelemetryUtility.StopTimer();
var actionTelemetryEvent = TelemetryUtility.GetActionTelemetryEvent(
new[] { Project },
NuGetOperationType.Update,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryUtility.GetTimerElapsedTimeInSeconds());
// emit telemetry event along with granular level for update operation
ActionsTelemetryService.Instance.EmitActionEvent(actionTelemetryEvent, TelemetryService.TelemetryEvents);
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
// Set to log telemetry granular events for this install operation
TelemetryService = new TelemetryServiceHelper();
// start timer for telemetry event
TelemetryUtility.StartorResumeTimer();
// Run Preprocess outside of JTF
Preprocess();
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await _lockService.ExecuteNuGetOperationAsync(() =>
{
SubscribeToProgressEvents();
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
TelemetryUtility.StopTimer();
var actionTelemetryEvent = TelemetryUtility.GetActionTelemetryEvent(
new[] { Project },
NuGetOperationType.Install,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryUtility.GetTimerElapsedTimeInSeconds());
// emit telemetry event along with granular level events
ActionsTelemetryService.Instance.EmitActionEvent(actionTelemetryEvent, TelemetryService.TelemetryEvents);
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
// Set to log telemetry granular events for this install operation
TelemetryService = new TelemetryServiceHelper();
// start timer for telemetry event
TelemetryUtility.StartorResumeTimer();
using (var lck = _lockService.AcquireLock())
{
Preprocess();
SubscribeToProgressEvents();
if (!_readFromPackagesConfig &&
!_readFromDirectPackagePath &&
_nugetVersion == null)
{
Task.Run(InstallPackageByIdAsync);
}
else
{
var identities = GetPackageIdentities();
Task.Run(() => InstallPackagesAsync(identities));
}
WaitAndLogPackageActions();
UnsubscribeFromProgressEvents();
}
// stop timer for telemetry event and create action telemetry event instance
TelemetryUtility.StopTimer();
var actionTelemetryEvent = TelemetryUtility.GetActionTelemetryEvent(
new[] { Project },
NuGetOperationType.Install,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryUtility.GetTimerElapsedTimeInSeconds());
// emit telemetry event along with granular level events
ActionsTelemetryService.Instance.EmitActionEvent(actionTelemetryEvent, TelemetryService.TelemetryEvents);
}
protected override void ProcessRecordCore()
{
var startTime = DateTimeOffset.Now;
_packageCount = 1;
// Enable granular level events for this uninstall operation
TelemetryService = new TelemetryServiceHelper();
TelemetryUtility.StartorResumeTimer();
// Run Preprocess outside of JTF
Preprocess();
NuGetUIThreadHelper.JoinableTaskFactory.Run(async() =>
{
await _lockService.ExecuteNuGetOperationAsync(() =>
{
SubscribeToProgressEvents();
Task.Run(UninstallPackageAsync);
WaitAndLogPackageActions();
UnsubscribeFromProgressEvents();
return(Task.FromResult(true));
}, Token);
});
TelemetryUtility.StopTimer();
var actionTelemetryEvent = TelemetryUtility.GetActionTelemetryEvent(
new[] { Project },
NuGetOperationType.Uninstall,
OperationSource.PMC,
startTime,
_status,
_packageCount,
TelemetryUtility.GetTimerElapsedTimeInSeconds());
// emit telemetry event with granular level events
ActionsTelemetryService.Instance.EmitActionEvent(actionTelemetryEvent, TelemetryService.TelemetryEvents);
}
/// <summary>
/// The internal implementation to perform user action.
/// </summary>
/// <param name="resolveActionsAsync">A function that returns a task that resolves the user
/// action into project actions.</param>
/// <param name="executeActionsAsync">A function that returns a task that executes
/// the project actions.</param>
private async Task PerformActionImplAsync(
INuGetUI uiService,
Func <Task <IReadOnlyList <ResolvedAction> > > resolveActionsAsync,
Func <IReadOnlyList <ResolvedAction>, Task> executeActionsAsync,
NuGetOperationType operationType,
CancellationToken token)
{
var status = NuGetOperationStatus.Succeeded;
var startTime = DateTimeOffset.Now;
var packageCount = 0;
var operationId = Guid.NewGuid().ToString();
// Enable granular level telemetry events for nuget ui operation
var telemetryService = new TelemetryServiceHelper();
uiService.ProjectContext.TelemetryService = telemetryService;
await _lockService.ExecuteNuGetOperationAsync(async() =>
{
try
{
uiService.BeginOperation();
var acceptedFormat = await CheckPackageManagementFormat(uiService, token);
if (!acceptedFormat)
{
return;
}
TelemetryUtility.StartorResumeTimer();
var actions = await resolveActionsAsync();
var results = GetPreviewResults(actions);
if (operationType == NuGetOperationType.Uninstall)
{
packageCount = results.SelectMany(result => result.Deleted).
Select(package => package.Id).Distinct().Count();
}
else
{
var addCount = results.SelectMany(result => result.Added).
Select(package => package.Id).Distinct().Count();
var updateCount = results.SelectMany(result => result.Updated).
Select(result => result.New.Id).Distinct().Count();
// update packages count
packageCount = addCount + updateCount;
if (updateCount > 0)
{
// set operation type to update when there are packages being updated
operationType = NuGetOperationType.Update;
}
}
TelemetryUtility.StopTimer();
// Show the preview window.
if (uiService.DisplayPreviewWindow)
{
var shouldContinue = uiService.PromptForPreviewAcceptance(results);
if (!shouldContinue)
{
return;
}
}
TelemetryUtility.StartorResumeTimer();
// Show the license acceptance window.
var accepted = await CheckLicenseAcceptanceAsync(uiService, results, token);
TelemetryUtility.StartorResumeTimer();
if (!accepted)
{
return;
}
// Warn about the fact that the "dotnet" TFM is deprecated.
if (uiService.DisplayDeprecatedFrameworkWindow)
{
var shouldContinue = ShouldContinueDueToDotnetDeprecation(uiService, actions, token);
TelemetryUtility.StartorResumeTimer();
if (!shouldContinue)
{
return;
}
}
if (!token.IsCancellationRequested)
{
// execute the actions
await executeActionsAsync(actions);
// fires ActionsExecuted event to update the UI
uiService.OnActionsExecuted(actions);
}
}
catch (System.Net.Http.HttpRequestException ex)
{
status = NuGetOperationStatus.Failed;
if (ex.InnerException != null)
{
uiService.ShowError(ex.InnerException);
}
else
{
uiService.ShowError(ex);
}
}
catch (Exception ex)
{
status = NuGetOperationStatus.Failed;
uiService.ShowError(ex);
}
finally
{
TelemetryUtility.StopTimer();
var duration = TelemetryUtility.GetTimerElapsedTime();
uiService.ProjectContext.Log(MessageLevel.Info,
string.Format(CultureInfo.CurrentCulture, Resources.Operation_TotalTime, duration));
uiService.EndOperation();
var actionTelemetryEvent = TelemetryUtility.GetActionTelemetryEvent(
uiService.Projects,
operationType,
OperationSource.UI,
startTime,
status,
packageCount,
duration.TotalSeconds);
ActionsTelemetryService.Instance.EmitActionEvent(actionTelemetryEvent, telemetryService.TelemetryEvents);
}
}, token);
}
public static void StartTimer(TelemetryServiceHelper telemetryHelper)
{
telemetryHelper?.StartorResumeTimer();
}
