private void SetGlobalContext(int uiCultureLCID, int cultureLCID, string serializedSession)
{
var session = new TelemetrySession(serializedSession);
session.Start();
EnsureCulture(uiCultureLCID, cultureLCID);
WatsonReporter.InitializeFatalErrorHandlers(session);
WatsonReporter.InitializeLogger(Logger);
// set roslyn loggers
RoslynServices.SetTelemetrySession(session);
RoslynLogger.SetLogger(AggregateLogger.Create(new VSTelemetryLogger(session), RoslynLogger.GetLogger()));
// start performance reporter
var diagnosticAnalyzerPerformanceTracker = SolutionService.PrimaryWorkspace.Services.GetService <IPerformanceTrackerService>();
if (diagnosticAnalyzerPerformanceTracker != null)
{
var globalOperationNotificationService = SolutionService.PrimaryWorkspace.Services.GetService <IGlobalOperationNotificationService>();
_performanceReporter = new PerformanceReporter(Logger, diagnosticAnalyzerPerformanceTracker, globalOperationNotificationService, s_reportInterval, _shutdownCancellationSource.Token);
}
}
protected override ILogger CreateLogger(TelemetrySession telemetrySession) =>
AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(_optionsService),
new VSTelemetryLogger(telemetrySession),
Logger.GetLogger()
);
private void SetGlobalContext(int uiCultureLCID, int cultureLCID, string?serializedSession)
{
// set global telemetry session
var session = GetTelemetrySession(serializedSession);
if (session == null)
{
return;
}
EnsureCulture(uiCultureLCID, cultureLCID);
// set roslyn loggers
RoslynServices.SetTelemetrySession(session);
RoslynLogger.SetLogger(AggregateLogger.Create(new VSTelemetryLogger(session), RoslynLogger.GetLogger()));
// set both handler as NFW
FatalError.Handler = ex => WatsonReporter.Report(ex, WatsonSeverity.Critical);
FatalError.NonFatalHandler = ex => WatsonReporter.Report(ex);
// start performance reporter
var diagnosticAnalyzerPerformanceTracker = SolutionService.PrimaryWorkspace.Services.GetService <IPerformanceTrackerService>();
if (diagnosticAnalyzerPerformanceTracker != null)
{
var globalOperationNotificationService = SolutionService.PrimaryWorkspace.Services.GetService <IGlobalOperationNotificationService>();
_performanceReporter = new PerformanceReporter(Logger, diagnosticAnalyzerPerformanceTracker, globalOperationNotificationService, s_reportInterval, _shutdownCancellationSource.Token);
}
}
protected override ILogger CreateLogger(TelemetrySession telemetrySession)
=> AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(FunctionIdOptions.CreateFunctionIsEnabledPredicate(_globalOptions)),
TelemetryLogger.Create(telemetrySession, _globalOptions),
new FileLogger(_globalOptions),
Logger.GetLogger());
public static void Initialize(IServiceProvider serviceProvider, TelemetrySession session)
{
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
var optionService = componentModel.GetService <IGlobalOptionService>();
Logger.SetLogger(
AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(optionService),
new VSTelemetryLogger(session),
Logger.GetLogger()));
Logger.Log(FunctionId.Run_Environment, KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
}
public void TestAllocationPooling()
{
Logger.SetLogger(AggregateLogger.Create(TestLogger.Instance, Logger.GetLogger()));
var block1 = LogBlock();
var block2 = LogBlock();
Assert.NotEqual(block1, block2);
block1.Dispose();
var block3 = LogBlock();
Assert.Same(block1, block3);
block2.Dispose();
block3.Dispose();
}
public async Task TestStorageDataIsNotRecomputed()
{
string solFile = Util.GetSampleProject("console-project", "ConsoleProject.sln");
var checkSum1 = await RunTest(usedCache : false);
var checkSum2 = await RunTest(usedCache : true);
Assert.AreEqual(checkSum1, checkSum2);
async Task <Microsoft.CodeAnalysis.Checksum> RunTest(bool usedCache)
{
var initial = Logger.GetLogger();
using (Solution sol = (Solution)await Services.ProjectService.ReadWorkspaceItem(Util.GetMonitor(), solFile))
using (var ws = await TypeSystemServiceTestExtensions.LoadSolution(sol)) {
try {
var persistentStorageService = ws.Services.GetService <IPersistentStorageService> ();
Assert.That(persistentStorageService, Is.TypeOf(typeof(Microsoft.CodeAnalysis.SQLite.SQLitePersistentStorageService)));
if (!(persistentStorageService is Microsoft.CodeAnalysis.SQLite.SQLitePersistentStorageService sqlitePersistentStorageService))
{
return(null);
}
var solutionSizeTracker = (IIncrementalAnalyzerProvider)Composition.CompositionManager.Instance.GetExportedValue <ISolutionSizeTracker> ();
// This will return the tracker, since it's a singleton.
var analyzer = solutionSizeTracker.CreateIncrementalAnalyzer(ws);
// We need this hack because we can't guess when the work coordinator will run the incremental analyzers.
await analyzer.NewSolutionSnapshotAsync(ws.CurrentSolution, CancellationToken.None);
var storageLogger = new StorageCheckingLogger();
var aggregateLogger = AggregateLogger.Create(initial, storageLogger);
Logger.SetLogger(aggregateLogger);
var provider = new SymbolTreeInfoIncrementalAnalyzerProvider();
var cacheService = (Microsoft.CodeAnalysis.FindSymbols.SymbolTree.ISymbolTreeInfoCacheService)provider.CreateService(ws.Services);
var incrementalAnalyzer = provider.CreateIncrementalAnalyzer(ws);
var project = sol.GetAllProjects().Single();
var roslynProject = IdeServices.TypeSystemService.GetProject(project);
await incrementalAnalyzer.AnalyzeProjectAsync(roslynProject, default, default, CancellationToken.None);
internal static void Initialize()
{
if (Interlocked.CompareExchange(ref initialized, 1, 0) == 1)
{
return;
}
// Initialize Roslyn foreground thread data.
ForegroundThreadAffinitizedObject.CurrentForegroundThreadData = new ForegroundThreadData(
Runtime.MainThread,
Runtime.MainTaskScheduler,
ForegroundThreadDataInfo.CreateDefault(ForegroundThreadDataKind.ForcedByPackageInitialize)
);
Logger.SetLogger(AggregateLogger.Create(
new RoslynLogger(),
Logger.GetLogger()
));
}
private static void SetGlobalContext(string serializedSession)
{
// set global telemetry session
var session = GetTelemetrySession(serializedSession);
if (session == null)
{
return;
}
// set roslyn loggers
WatsonReporter.SetTelemetrySession(session);
RoslynLogger.SetLogger(AggregateLogger.Create(new VSTelemetryLogger(session), RoslynLogger.GetLogger()));
// set both handler as NFW
FatalError.Handler = WatsonReporter.Report;
FatalError.NonFatalHandler = WatsonReporter.Report;
}
public static void Initialize(IServiceProvider serviceProvider)
{
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
var optionService = componentModel.GetService <IGlobalOptionService>();
// Fetch the session synchronously on the UI thread; if this doesn't happen before we try using this on
// the background thread then we will experience hangs like we see in this bug:
// https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?_a=edit&id=190808 or
// https://devdiv.visualstudio.com/DevDiv/_workitems?id=296981&_a=edit
var session = TelemetryService.DefaultSession;
Logger.SetLogger(
AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(optionService),
new VSTelemetryLogger(session),
Logger.GetLogger()));
Logger.Log(FunctionId.Run_Environment, KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
}
static void AttachLoggers()
{
var fullRoslynEnvValue = Environment.GetEnvironmentVariable("MONODEVELOP_FULL_ROSLYN_LOG");
var fullRoslynLogEnabled = bool.TryParse(fullRoslynEnvValue, out var value) && value;
ILogger[] loggers;
if (fullRoslynLogEnabled)
{
loggers = new ILogger[] {
new RoslynLogger(),
new RoslynFileLogger(),
Logger.GetLogger()
};
}
else
{
loggers = new ILogger[] {
new RoslynLogger(),
Logger.GetLogger()
};
}
Logger.SetLogger(AggregateLogger.Create(loggers));
}
public void Initialize(IServiceProvider serviceProvider)
{
var componentModel = (IComponentModel)serviceProvider.GetService(typeof(SComponentModel));
var workspace = componentModel.GetService <VisualStudioWorkspace>();
// initialize host context on UI thread.
var projectTypeLookup = workspace.Services.GetService <IProjectTypeLookupService>();
// set initial logger
var optionService = workspace.Services.GetService <IOptionService>();
var loggingChecker = Logger.GetLoggingChecker(optionService);
var telemetryService = serviceProvider.GetService(typeof(SVsTelemetryService)) as IVsTelemetryService;
Logger.SetLogger(
AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(loggingChecker),
new VSTelemetryLogger(telemetryService),
new VSTelemetryActivityLogger(telemetryService),
Logger.GetLogger()));
Logger.Log(FunctionId.Run_Environment, KeyValueLogMessage.Create(m => m["Version"] = FileVersionInfo.GetVersionInfo(typeof(VisualStudioWorkspace).Assembly.Location).FileVersion));
}
protected override ILogger CreateLogger(TelemetrySession telemetrySession)
=> AggregateLogger.Create(
TelemetryLogger.Create(telemetrySession, _globalOptions),
Logger.GetLogger());
protected override ILogger CreateLogger(TelemetrySession telemetrySession)
=> AggregateLogger.Create(
new VSTelemetryLogger(telemetrySession),
Logger.GetLogger());
protected override ILogger CreateLogger(TelemetrySession telemetrySession, bool logDelta)
=> AggregateLogger.Create(
TelemetryLogger.Create(telemetrySession, logDelta),
Logger.GetLogger());