private void InitializeLogging()
{
try {
var registry = ComponentModel.GetService <IInterpreterRegistryService>();
if (registry != null) // not available in some test cases...
// log interesting stats on startup
{
var installed = registry.Configurations.Count();
var installedV2 = registry.Configurations.Count(c => c.Version.Major == 2);
var installedV3 = registry.Configurations.Count(c => c.Version.Major == 3);
_logger.LogEvent(PythonLogEvent.InstalledInterpreters, new Dictionary <string, object> {
{ "Total", installed },
{ "3x", installedV3 },
{ "2x", installedV2 }
});
}
_logger.LogEvent(PythonLogEvent.Experiments, new Dictionary <string, object> {
{ "NoDatabaseFactory", ExperimentalOptions.NoDatabaseFactory },
{ "AutoDetectCondaEnvironments", ExperimentalOptions.AutoDetectCondaEnvironments },
{ "UseCondaPackageManager", ExperimentalOptions.UseCondaPackageManager },
{ "UseVsCodeDebugger", ExperimentalOptions.UseVsCodeDebugger }
});
} catch (Exception ex) {
Debug.Fail(ex.ToUnhandledExceptionMessage(GetType()));
}
}
public void OnTelemetryEvent(JToken arg)
{
if (!(arg is JObject telemetry))
{
return;
}
Trace.WriteLine(telemetry.ToString());
try {
var te = telemetry.ToObject <PylanceTelemetryEvent>();
if (te == null)
{
return;
}
if (te.Exception == null)
{
_logger.LogEvent(te.EventName, te.Properties, te.Measurements);
}
else
{
_logger.LogFault(new PylanceException(te.EventName, te.Exception.stack), te.EventName, false);
}
// Special case language_server/analysis_complete. We need this for testing so we
// know when it's okay to try to bring up intellisense
if (te.EventName == "language_server/analysis_complete")
{
AnalysisComplete.Invoke(this, EventArgs.Empty);
}
} catch {
}
}
public override Task ApplyAsync()
{
_logger?.LogEvent(PythonLogEvent.InstallEnv, null);
var ids = AvailablePackages.OfType <SetupPackageView>().Where(p => p.IsChecked).Select(p => p.PackageId).ToArray();
if (ids.Length > 0)
{
IVsProjectAcquisitionSetupDriver driver;
if (_retargeting != null &&
ErrorHandler.Succeeded(_retargeting.GetSetupDriver(VSConstants.SetupDrivers.SetupDriver_VS, out driver)) &&
driver != null)
{
var task = driver.Install(ids);
if (task != null)
{
task.Start();
}
}
}
else
{
Debug.Fail("Accept button should have been disabled");
}
return(Task.CompletedTask);
}
private void OnAnalysisProcessExited(object sender, AbnormalAnalysisExitEventArgs e)
{
_analyzerAbnormalExitCount++;
if (_logger == null)
{
return;
}
var msg = new StringBuilder()
.AppendFormat("Exit Code: {0}", e.ExitCode)
.AppendLine()
.AppendLine(" ------ STD ERR ------ ")
.Append(e.StdErr)
.AppendLine(" ------ END STD ERR ------ ");
_logger.LogEvent(
PythonLogEvent.AnalysisExitedAbnormally,
msg.ToString()
);
if (_analyzerAbnormalExitCount < 5)
{
// Start a new analyzer
ReanalyzeAsync().HandleAllExceptions(_site).DoNotWait();
}
}
public async override Task ApplyAsync()
{
bool failed = false;
if (IsCustomInterpreter)
{
try {
await ApplyCustomAsync();
} catch (Exception ex) when(!ex.IsCriticalException())
{
failed = true;
throw;
} finally {
_logger?.LogEvent(PythonLogEvent.AddExistingEnv, new AddExistingEnvInfo()
{
Failed = failed,
LanguageVersion = VersionName,
Architecture = ArchitectureName,
Custom = true,
Global = RegisterCustomEnv,
});
}
}
else
{
try {
await ApplyExistingAsync();
} catch (Exception ex) when(!ex.IsCriticalException())
{
failed = true;
throw;
} finally {
_logger?.LogEvent(PythonLogEvent.AddExistingEnv, new AddExistingEnvInfo()
{
Failed = failed,
LanguageVersion = SelectedInterpreter.LanguageVersion,
Architecture = SelectedInterpreter.Architecture,
});
}
}
}
public override Task ApplyAsync()
{
_logger?.LogEvent(PythonLogEvent.InstallEnv, null);
var setupService = Site.GetService(typeof(SVsSetupCompositionService)) as IVsSetupCompositionService;
string installerPath = setupService?.InstallerPath;
if (File.Exists(installerPath))
{
Process.Start(installerPath)?.Dispose();
}
return(Task.CompletedTask);
}
public override void Invoke(object inArg, IntPtr outArg, OLECMDEXECOPT options)
{
// getting the current value
if (outArg != IntPtr.Zero)
{
var text = _envSwitchMgr.CurrentFactory?.Configuration.Description ?? string.Empty;
Marshal.GetNativeVariantForObject(text, outArg);
}
// setting the current value
if (inArg != null)
{
var text = inArg as string;
var factory = _envSwitchMgr.AllFactories.SingleOrDefault(f => f.Configuration.Description == text);
if (factory != null)
{
_logger?.LogEvent(PythonLogEvent.SelectEnvFromToolbar, new SelectEnvFromToolbarInfo()
{
InterpreterId = factory.Configuration.Id,
Architecture = factory.Configuration.Architecture.ToString(),
Version = factory.Configuration.Version.ToString(),
IsIronPython = factory.Configuration.IsIronPython(),
});
SwitchToFactoryAsync(factory).HandleAllExceptions(_serviceProvider, GetType()).DoNotWait();
}
else
{
// The special "Add Environment..." entry, or any entry that no longer exists brings up the add dialog
_logger?.LogEvent(PythonLogEvent.AddEnvFromToolbar, null);
AddEnvironmentCommand
.AddEnvironmentAsync(_envSwitchMgr, _serviceProvider, AddEnvironmentDialog.PageKind.VirtualEnvironment)
.HandleAllExceptions(_serviceProvider, GetType())
.DoNotWait();
}
}
}
private async Task CreateVirtualEnvironmentAsync(ITaskHandler taskHandler)
{
IPythonInterpreterFactory factory = null;
bool failed = true;
var baseInterp = _registry.FindInterpreter(_baseInterpreter);
try {
factory = await VirtualEnv.CreateAndAddFactory(
_site,
_registry,
_options,
_project,
_workspace,
_virtualEnvPath,
baseInterp,
_registerAsCustomEnv,
_customEnvName,
_useVEnv
);
if (factory != null)
{
if (_installReqs && File.Exists(_reqsPath))
{
await InstallPackagesAsync(taskHandler, factory);
}
await _site.GetUIThread().InvokeTask(async() => {
// Note that for a workspace, VirtualEnv.CreateAndAddFactory
// takes care of updating PythonSettings.json, as that is
// required in order to obtain the factory. So no need to do
// anything here for workspace.
if (_project != null)
{
_project.AddInterpreter(factory.Configuration.Id);
if (_setAsCurrent)
{
_project.SetInterpreterFactory(factory);
}
}
if (_setAsDefault && _options != null)
{
_options.DefaultInterpreter = factory;
}
if (_viewInEnvWindow)
{
await InterpreterListToolWindow.OpenAtAsync(_site, factory);
}
});
}
failed = false;
} finally {
_logger?.LogEvent(PythonLogEvent.CreateVirtualEnv, new CreateVirtualEnvInfo()
{
Failed = failed,
InstallRequirements = _installReqs,
UseVEnv = _useVEnv,
Global = _registerAsCustomEnv,
LanguageVersion = baseInterp?.Configuration?.Version.ToString() ?? "",
Architecture = baseInterp?.Configuration?.ArchitectureString ?? "",
SetAsDefault = _setAsDefault,
SetAsCurrent = _setAsCurrent,
OpenEnvironmentsWindow = _viewInEnvWindow,
});
}
taskHandler?.Progress.Report(new TaskProgressData()
{
CanBeCanceled = false,
ProgressText = Strings.VirtualEnvStatusCenterCreateProgressCompleted,
PercentComplete = 100,
});
}
private async void Listener_ProgressUpdate(Dictionary <string, AnalysisProgress> status)
{
bool anyUpdates = status.Any();
if (!anyUpdates)
{
lock (_environments) {
anyUpdates = _currentlyRefreshing.Count != 0;
}
}
if (anyUpdates)
{
var updates = new List <DispatcherOperation>();
lock (_environments) {
foreach (var env in _environments)
{
if (env.Factory == null)
{
continue;
}
AnalysisProgress progress;
if (status.TryGetValue(AnalyzerStatusUpdater.GetIdentifier(env.Factory), out progress))
{
_currentlyRefreshing[env.Factory] = progress;
updates.Add(env.Dispatcher.InvokeAsync(() => {
if (progress.Maximum > 0)
{
var percent = progress.Progress * 100 / progress.Maximum;
var current = env.RefreshDBProgress;
// Filter out small instances of 'reverse'
// progress, but allow big jumps backwards.
if (percent > current || percent < current - 25)
{
env.RefreshDBProgress = percent;
}
env.IsRefreshDBProgressIndeterminate = false;
}
else
{
env.IsRefreshDBProgressIndeterminate = true;
}
env.RefreshDBMessage = progress.Message;
env.IsRefreshingDB = true;
}));
}
else if (_currentlyRefreshing.TryGetValue(env.Factory, out progress))
{
_currentlyRefreshing.Remove(env.Factory);
try {
TelemetryLogger?.LogEvent(PythonLogEvent.AnalysisCompleted, new AnalysisInfo {
InterpreterId = env.Factory.Configuration.Id,
AnalysisSeconds = progress.Seconds
});
} catch (Exception ex) {
Debug.Fail(ex.ToUnhandledExceptionMessage(GetType()));
}
updates.Add(env.Dispatcher.InvokeAsync(() => {
env.IsRefreshingDB = false;
env.IsRefreshDBProgressIndeterminate = false;
env.RefreshDBMessage = string.Empty;
CommandManager.InvalidateRequerySuggested();
}));
}
}
}
try {
await Task.WhenAll(updates.Select(d => d.Task).ToArray());
} catch (OperationCanceledException) {
// Tasks were cancelled, which probably means we are closing.
// In this case, _timer will be disposed before the next update.
}
}
if (Interlocked.Decrement(ref _listenerTimeToLive) == 0)
{
// It's time to reset the listener. We do this periodically in
// case the global mutex has become abandoned. By releasing our
// handle, it should go away and any errors (which may be caused
// by users killing the analyzer) become transient rather than
// permanent.
// Because we are currently on the listener's thread, we need to
// recreate on a separate thread so that this one can terminate.
Task.Run((Action)CreateListener)
.HandleAllExceptions(Site, GetType())
.DoNotWait();
}
}