private void EventsOnSessionEnd(object sender, SessionEndEventArgs e) { try { if (_coverageFlushed) { return; } var mutationCoverage = Utils.ReadMutationCoverageFile(); // Filter out functions that are not tests mutationCoverage.Coverage = mutationCoverage.Coverage .Where(pair => _testNames.Contains(pair.Key)) .ToDictionary(pair => pair.Key, pair => pair.Value); Utils.WriteMutationCoverageFile(mutationCoverage); _coverageFlushed = true; } catch (Exception ex) { _logger.LogError(context.SessionDataCollectionContext, $"Test Session Exception: {ex}"); } _logger.LogWarning(context.SessionDataCollectionContext, "Coverage Test Session Finished"); }
/// <summary> /// SessionEnd event handler /// </summary> /// <param name="sender">Sender</param> /// <param name="e">Event args</param> private void OnSessionEnd(object sender, SessionEndEventArgs e) { try { _eqtTrace.Verbose("{0}: SessionEnd received", CoverletConstants.DataCollectorName); // Get coverage reports IEnumerable <(string report, string fileName)> coverageReports = _coverageManager?.GetCoverageReports(); if (coverageReports != null && coverageReports.Count() > 0) { // Send result attachments to test platform. using (var attachmentManager = new AttachmentManager(_dataSink, _dataCollectionContext, _logger, _eqtTrace, _countDownEventFactory.Create(coverageReports.Count(), TimeSpan.FromSeconds(30)))) { foreach ((string report, string fileName) in coverageReports) { attachmentManager.SendCoverageReport(report, fileName); } } } else { _eqtTrace.Verbose("{0}: No coverage reports specified", CoverletConstants.DataCollectorName); } } catch (Exception ex) { _logger.LogWarning(ex.ToString()); this.Dispose(true); } }
private void SessionEnded_Handler(object sender, SessionEndEventArgs args) { //logger.LogError(this.context.SessionDataCollectionContext, new Exception("my exception")); //logger.LogWarning(this.context.SessionDataCollectionContext, "my arning"); //logger.LogException(context.SessionDataCollectionContext, new Exception("abc"), DataCollectorMessageLevel.Error); this.logger.LogWarning(this.context.SessionDataCollectionContext, "SessionEnded"); }
private void OnSessionEnd(object sender, SessionEndEventArgs e) { Trace.TraceInformation("Session ended"); mSessionEnded(); mFileWriterThing.LastOrDefaultAsync().Wait(); mDataSink.SendFileAsync(e.Context, mDataFilePath, true); }
private void SessionEnded_Handler(object sender, SessionEndEventArgs e) { string tmpAttachment = Path.Combine(_tempDirectoryPath, Guid.NewGuid().ToString("N"), "DataCollectorAttachmentProcessor_1.txt"); Directory.CreateDirectory(Path.GetDirectoryName(tmpAttachment)); File.WriteAllText(tmpAttachment, $"SessionEnded_Handler_{Guid.NewGuid():N}"); _dataCollectionSink.SendFileAsync(_context.SessionDataCollectionContext, tmpAttachment, true); }
public void SessionEndShouldStopVanguard() { var sessionEndEventArgs = new SessionEndEventArgs(); this.collectorImpl.SessionEnd(null, sessionEndEventArgs); this.vanguardMock.Verify(v => v.Stop()); }
/// <summary> /// Called when Session End event is invoked /// </summary> /// <param name="sender">Sender</param> /// <param name="args">SessionEndEventArgs</param> private void SessionEnded_Handler(object sender, SessionEndEventArgs args) { if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("Blame Collector : Session End"); } try { // If the last test crashes, it will not invoke a test case end and therefore // In case of crash testStartCount will be greater than testEndCount and we need to write the sequence // And send the attachment if (this.testStartCount > this.testEndCount) { var filepath = Path.Combine(this.GetResultsDirectory(), Constants.AttachmentFileName + "_" + this.attachmentGuid); filepath = this.blameReaderWriter.WriteTestSequence(this.testSequence, this.testObjectDictionary, filepath); var fileTranferInformation = new FileTransferInformation(this.context.SessionDataCollectionContext, filepath, true); this.dataCollectionSink.SendFileAsync(fileTranferInformation); } if (this.processDumpEnabled) { // If there was a test case crash or if we need to collect dump on process exit. if (this.testStartCount > this.testEndCount || this.collectDumpAlways) { try { var dumpFile = this.processDumpUtility.GetDumpFile(); if (!string.IsNullOrEmpty(dumpFile)) { var fileTranferInformation = new FileTransferInformation(this.context.SessionDataCollectionContext, dumpFile, true); this.dataCollectionSink.SendFileAsync(fileTranferInformation); } else { EqtTrace.Warning("BlameCollector.SessionEnded_Handler: blame:CollectDump was enabled but dump file was not generated."); this.logger.LogWarning(args.Context, Resources.Resources.ProcDumpNotGenerated); } } catch (FileNotFoundException ex) { EqtTrace.Warning(ex.Message); this.logger.LogWarning(args.Context, ex.Message); } } } } finally { // Attempt to terminate the proc dump process if proc dump was enabled if (this.processDumpEnabled) { this.processDumpUtility.TerminateProcess(); } this.DeregisterEvents(); } }
public void SessionEndShouldSendCoverageFile() { string tempFile = Path.GetTempFileName(); var sessionEndEventArgs = new SessionEndEventArgs(); this.fileHelperMock.Setup(f => f.Exists(It.IsAny <string>())).Returns(true); this.collectorImpl.SessionEnd(null, sessionEndEventArgs); this.dataCollectionSinkMock.Verify(s => s.SendFileAsync(It.IsAny <DataCollectionContext>(), It.IsAny <string>(), false)); }
private void OnSessionEnd(object sender, SessionEndEventArgs e) { ValidateArg.NotNull(e, "SessionEndEventArgs"); ValidateArg.NotNull(e.Context, "SessionEndEventArgs.Context"); if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose("EventLogDataCollector: SessionEnd received"); } this.WriteCollectedEventLogEntries(e.Context, true, TimeSpan.MaxValue, DateTime.Now); }
/// <inheritdoc/> public Collection <AttachmentSet> SessionEnded(bool isCancelled = false) { // Return null if datacollection is not enabled. if (!this.isDataCollectionEnabled) { return(new Collection <AttachmentSet>()); } if (isCancelled) { this.attachmentManager.Cancel(); return(new Collection <AttachmentSet>()); } var endEvent = new SessionEndEventArgs(this.dataCollectionEnvironmentContext.SessionDataCollectionContext); this.SendEvent(endEvent); List <AttachmentSet> result = new List <AttachmentSet>(); try { result = this.attachmentManager.GetAttachments(endEvent.Context); } catch (Exception ex) { if (EqtTrace.IsErrorEnabled) { EqtTrace.Error("DataCollectionManager.SessionEnded: Failed to get attachments : {0}", ex.Message); } return(new Collection <AttachmentSet>(result)); } foreach (var entry in result) { foreach (var file in entry.Attachments) { if (EqtTrace.IsVerboseEnabled) { EqtTrace.Verbose( "Run Attachment Description: Collector:'{0}' Uri:'{1}' Description:'{2}' Uri:'{3}' ", entry.DisplayName, entry.Uri, file.Description, file.Uri); } } } return(new Collection <AttachmentSet>(result)); }
public void RaiseEventsShouldRaiseEventsIfSessionEndEventArgsIsPassed() { this.isEventRaised = false; var testCase = new TestCase(); this.context = new DataCollectionContext(testCase); this.events.SessionEnd += this.SessionEndMessageHandler; var eventArgs = new SessionEndEventArgs(this.context); this.events.RaiseEvent(eventArgs); Assert.IsTrue(this.isEventRaised); }
private void EventsOnSessionEnd(object sender, SessionEndEventArgs e) { try { var serialized = _testResults.Serialize(); File.WriteAllBytes(TestRunnerConstants.TestsFileName, serialized); } catch (Exception) { _logger.LogError(context.SessionDataCollectionContext, "Test Session Exception: {ex}"); } _logger.LogWarning(context.SessionDataCollectionContext, "Test Session Finished"); }
void SessionEnded_Handler(object sender, SessionEndEventArgs e) { clocks.TryGetValue($"{e.Context?.SessionId?.Id}", out Stopwatch clock); log.Value.Log(new { Name = "TestSessionEnded", RequestId = BuildArn ?? $"{e.Context?.SessionId?.Id}", Response = new { StatusCode = 200, RequestDuration = clock.Elapsed.TotalMilliseconds } }); log2.LogWarning(e.Context, "SessionEnded"); }
private void Events_SessionEnd(object sender, SessionEndEventArgs e) { try { foreach (var file in Directory.GetFiles(_traceDirectory)) { _logger.LogWarning(e.Context, $"Saving event pipe session: {file}"); _dataSink.SendFileAsync(e.Context, file, deleteFile: true); } } catch (Exception ex) { _logger.LogError(e.Context, "Error during SessionEnd", ex); } }
/// <summary> /// SessionEnd event handler /// </summary> /// <param name="sender">Sender</param> /// <param name="e">Event args</param> private void OnSessionEnd(object sender, SessionEndEventArgs e) { try { _eqtTrace.Verbose("{0}: SessionEnd received", CoverletConstants.DataCollectorName); // Get coverage reports string coverageReport = _coverageManager?.GetCoverageReport(); // Send result attachments to test platform. var attachmentManager = new AttachmentManager(_dataSink, _dataCollectionContext, _logger, _eqtTrace, this.GetReportFileName()); attachmentManager?.SendCoverageReport(coverageReport); } catch (Exception ex) { _logger.LogWarning(ex.ToString()); this.Dispose(true); } }
/// <summary> /// Called when Session End event is invoked /// </summary> /// <param name="sender">Sender</param> /// <param name="args">SessionEndEventArgs</param> private void SessionEnded_Handler(object sender, SessionEndEventArgs args) { if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("Blame Collector : Session End"); } // If the last test crashes, it will not invoke a test case end and therefore // In case of crash testStartCount will be greater than testEndCount and we need to write the sequence // And send the attachment if (this.testStartCount > this.testEndCount) { var filepath = Path.Combine(this.GetResultsDirectory(), Constants.AttachmentFileName); filepath = this.blameReaderWriter.WriteTestSequence(this.testSequence, filepath); var fileTranferInformation = new FileTransferInformation(this.context.SessionDataCollectionContext, filepath, true); this.dataCollectionSink.SendFileAsync(fileTranferInformation); } this.DeregisterEvents(); }
/// <inheritdoc/> public Collection <AttachmentSet> SessionEnded(bool isCancelled = false) { // Return null if datacollection is not enabled. if (!this.isDataCollectionEnabled) { return(new Collection <AttachmentSet>()); } if (isCancelled) { this.attachmentManager.Cancel(); return(new Collection <AttachmentSet>()); } var endEvent = new SessionEndEventArgs(this.dataCollectionEnvironmentContext.SessionDataCollectionContext); this.SendEvent(endEvent); var result = new List <AttachmentSet>(); try { result = this.attachmentManager.GetAttachments(endEvent.Context); } catch (Exception ex) { if (EqtTrace.IsErrorEnabled) { EqtTrace.Error("DataCollectionManager.SessionEnded: Failed to get attachments : {0}", ex); } return(new Collection <AttachmentSet>(result)); } if (EqtTrace.IsVerboseEnabled) { this.LogAttachments(result); } return(new Collection <AttachmentSet>(result)); }
private void OnSessionEnd(object sender, SessionEndEventArgs e) { _nyanCat.Stop(); }
/// <inheritdoc /> public void SendTestSessionEnd(SessionEndEventArgs e) { this.communicationManager.SendMessage(MessageType.SessionEnd, e); }
/// <summary> /// Called when Session End event is invoked /// </summary> /// <param name="sender">Sender</param> /// <param name="args">SessionEndEventArgs</param> private void SessionEndedHandler(object sender, SessionEndEventArgs args) { this.ResetInactivityTimer(); if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("Blame Collector : Session End"); } try { // If the last test crashes, it will not invoke a test case end and therefore // In case of crash testStartCount will be greater than testEndCount and we need to write the sequence // And send the attachment if (this.testStartCount > this.testEndCount) { var filepath = Path.Combine(this.GetTempDirectory(), Constants.AttachmentFileName + "_" + this.attachmentGuid); filepath = this.blameReaderWriter.WriteTestSequence(this.testSequence, this.testObjectDictionary, filepath); var fti = new FileTransferInformation(this.context.SessionDataCollectionContext, filepath, true); this.dataCollectionSink.SendFileAsync(fti); } else { if (this.collectProcessDumpOnTestHostHang) { this.logger.LogWarning(this.context.SessionDataCollectionContext, Resources.Resources.NotGeneratingSequenceFile); } } if (this.uploadDumpFiles) { try { var dumpFiles = this.processDumpUtility.GetDumpFiles(warnOnNoDumpFiles: this.collectDumpAlways); foreach (var dumpFile in dumpFiles) { if (!string.IsNullOrEmpty(dumpFile)) { try { var fileTranferInformation = new FileTransferInformation(this.context.SessionDataCollectionContext, dumpFile, true); this.dataCollectionSink.SendFileAsync(fileTranferInformation); } catch (FileNotFoundException ex) { EqtTrace.Warning(ex.ToString()); this.logger.LogWarning(args.Context, ex.ToString()); } } } } catch (FileNotFoundException ex) { EqtTrace.Warning(ex.ToString()); this.logger.LogWarning(args.Context, ex.ToString()); } } else { EqtTrace.Info("BlameCollector.CollectDumpAndAbortTesthost: Custom path to dump directory was provided via VSTEST_DUMP_PATH. Skipping attachment upload, the caller is responsible for collecting and uploading the dumps themselves."); } } finally { // Attempt to terminate the proc dump process if proc dump was enabled if (this.collectProcessDumpOnTrigger) { this.processDumpUtility.DetachFromTargetProcess(this.testHostProcessId); } this.DeregisterEvents(); } }
/// <inheritdoc /> public void RaiseSessionEnd(SessionEndEventArgs e) { this.SessionEnd.SafeInvoke(this, e, "DataCollectionTestCaseEventManager.RaiseSessionEnd"); }
private void SessionEndMessageHandler(object sender, SessionEndEventArgs e) { this.isEventRaised = true; }
/// <summary> /// Called when Session End event is invoked /// </summary> /// <param name="sender">Sender</param> /// <param name="args">SessionEndEventArgs</param> private void SessionEndedHandler(object sender, SessionEndEventArgs args) { this.ResetInactivityTimer(); if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("Blame Collector : Session End"); } try { // If the last test crashes, it will not invoke a test case end and therefore // In case of crash testStartCount will be greater than testEndCount and we need to write the sequence // And send the attachment if (this.testStartCount > this.testEndCount) { var filepath = Path.Combine(this.GetTempDirectory(), Constants.AttachmentFileName + "_" + this.attachmentGuid); filepath = this.blameReaderWriter.WriteTestSequence(this.testSequence, this.testObjectDictionary, filepath); var fileTranferInformation = new FileTransferInformation(this.context.SessionDataCollectionContext, filepath, true); this.dataCollectionSink.SendFileAsync(fileTranferInformation); } if (this.collectProcessDumpOnTrigger) { // If there was a test case crash or if we need to collect dump on process exit. // // Do not try to collect dump when we already collected one from the hang dump // we won't dump the killed process again and that would just show a warning on the command line if ((this.testStartCount > this.testEndCount || this.collectDumpAlways) && !this.dumpWasCollectedByHangDumper) { try { var dumpFile = this.processDumpUtility.GetDumpFile(); if (!string.IsNullOrEmpty(dumpFile)) { var fileTranferInformation = new FileTransferInformation(this.context.SessionDataCollectionContext, dumpFile, true); this.dataCollectionSink.SendFileAsync(fileTranferInformation); } else { EqtTrace.Warning("BlameCollector.SessionEndedHandler: blame:CollectDump was enabled but dump file was not generated."); this.logger.LogWarning(args.Context, Resources.Resources.ProcDumpNotGenerated); } } catch (FileNotFoundException ex) { EqtTrace.Warning(ex.ToString()); this.logger.LogWarning(args.Context, ex.ToString()); } } } } finally { // Attempt to terminate the proc dump process if proc dump was enabled if (this.collectProcessDumpOnTrigger) { this.processDumpUtility.DetachFromTargetProcess(this.testHostProcessId); } this.DeregisterEvents(); } }
/// <summary> /// Session end /// </summary> /// <param name="sender">Sender</param> /// <param name="e">Event arguments</param> public void SessionEnd(object sender, SessionEndEventArgs e) { this.StopVanguard(e.Context); }
/// <summary> /// On session end /// </summary> /// <param name="sender">Sender</param> /// <param name="e">Event arguments</param> private void SessionEnd(object sender, SessionEndEventArgs e) { this.implementation.SessionEnd(sender, e); }
private void SessionEnded_Handler(object sender, SessionEndEventArgs args) { }
/// <summary> /// The trigger session end. /// </summary> /// <param name="sender"> /// The sender. /// </param> /// <param name="e"> /// The e. /// </param> private void TriggerTestSessionEnd(object sender, SessionEndEventArgs e) { var testSessionEndArgs = new TestSessionEndArgs(); this.TriggerInProcDataCollectionMethods(Constants.TestSessionEndMethodName, testSessionEndArgs); }
private void TriggerTestSessionEnd(object sender, SessionEndEventArgs e) { this.dataCollectionTestCaseEventSender.SendTestSessionEnd(e); }
private void OnSessionEnd(object?sender, SessionEndEventArgs e) { _logger?.SetContext(e.Context); }