/// <summary> /// Initializes with the argument that was provided with the command. /// </summary> /// <param name="argument">Argument that was provided with the command.</param> public void Initialize(string argument) { if (string.IsNullOrWhiteSpace(argument)) { HandleInvalidArgument(argument); } else { string loggerIdentifier = null; Dictionary <string, string> parameters = null; var parseSucceeded = LoggerUtilities.TryParseLoggerArgument(argument, out loggerIdentifier, out parameters); if (parseSucceeded) { if (loggerIdentifier.Equals(ConsoleLogger.FriendlyName, StringComparison.OrdinalIgnoreCase)) { this.loggerManager.AddLogger(new ConsoleLogger(), ConsoleLogger.ExtensionUri, parameters); } else { this.loggerManager.UpdateLoggerList(argument, loggerIdentifier, parameters); } } else { HandleInvalidArgument(argument); } } }
/// <summary> /// Applies the document actions to the given set of documents. /// </summary> public async Task ApplyDocumentActionsAsync(IEnumerable <string> paths) { if (paths == null) { throw new ArgumentNullException(nameof(paths)); } var remainingPaths = new HashSet <string>(paths); try { var activeWindow = _dte.ActiveWindow; foreach (var path in paths) { await ApplyDocumentActionsAsync(path); remainingPaths.Remove(path); } if (activeWindow != null) { activeWindow.Activate(); } } finally { if (remainingPaths.Any()) { string ErrorMessageFormat = @"The following files were not formatted: " + Environment.NewLine + "{0}"; LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, string.Join(Environment.NewLine, remainingPaths))); } } }
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory) { if (env.IsDevelopment()) { app.UseDeveloperExceptionPage(); } LoggerUtilities.ConfigureLogger(env, loggerFactory, Configuration); app.ConfigureSwagger(); app.UseHttpsRedirection(); app.UseRouting(); //app.UseAuthentication(); //app.UseAuthorization(); app.UseSecurityMiddlewares(); app.UseCorsMiddleware(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); }
/// <summary> /// Initializes with the argument that was provided with the command. /// </summary> /// <param name="argument">Argument that was provided with the command.</param> public void Initialize(string argument) { string exceptionMessage = string.Format(CultureInfo.CurrentUICulture, CommandLineResources.LoggerUriInvalid, argument); // Throw error in case logger argument null or empty. if (string.IsNullOrWhiteSpace(argument)) { throw new CommandLineException(exceptionMessage); } // Get logger argument list. var loggerArgumentList = ArgumentProcessorUtilities.GetArgumentList(argument, ArgumentProcessorUtilities.SemiColonArgumentSeparator, exceptionMessage); // Get logger identifier. var loggerIdentifier = loggerArgumentList[0]; if (loggerIdentifier.Contains("=")) { throw new CommandLineException(exceptionMessage); } // Get logger parameters var loggerParameterArgs = loggerArgumentList.Skip(1); var loggerParameters = ArgumentProcessorUtilities.GetArgumentParameters(loggerParameterArgs, ArgumentProcessorUtilities.EqualNameValueSeparator, exceptionMessage); // Add logger to run settings. LoggerUtilities.AddLoggerToRunSettings(loggerIdentifier, loggerParameters, runSettingsManager); }
/// <summary> /// Save Log to a txt file. File Path needed in app.config /// </summary> /// <param name="loglevel">Depends on the severity of the log</param> /// <param name="message">Any text the user would like to add</param> /// <param name="exception">Can be null, when logging in trace or debug mode</param> /// <returns>Boolean for unit test purpose</returns> private Boolean File(LogObject loglevel, String message, Exception exception = null) { Boolean response = false; try { if (message == null || message.Length == 0 || loglevel == null) { return(response); } LoggerUtilities.GetLogObject(loglevel, message, exception); String currentPath = String.Format("{0}{1}{2}", MainPath, DateTime.Now.ToShortDateString().Replace("/", "_"), ".txt"); using (StreamWriter logFile = System.IO.File.AppendText(currentPath)) { String logMessage = LoggerUtilities.FormatLogMessage(loglevel); logFile.WriteLine(logMessage); response = true; } } catch (Exception ex) { LoggerUtilities.ShowUnexpectedError("file", ex); } return(response); }
private bool RunTests(IRequestData requestData, TestRunCriteria testRunCriteria, ITestRunEventsRegistrar testRunEventsRegistrar) { // Make sure to run the run request inside a lock as the below section is not thread-safe // TranslationLayer can process faster as it directly gets the raw unserialized messages whereas // below logic needs to deserialize and do some cleanup // While this section is cleaning up, TranslationLayer can trigger run causing multiple threads to run the below section at the same time lock (syncobject) { bool success = true; try { using (ITestRunRequest testRunRequest = this.testPlatform.CreateTestRunRequest(requestData, testRunCriteria)) { this.currentTestRunRequest = testRunRequest; this.runRequestCreatedEventHandle.Set(); try { this.testLoggerManager.RegisterTestRunEvents(testRunRequest); this.testRunResultAggregator.RegisterTestRunEvents(testRunRequest); testRunEventsRegistrar?.RegisterTestRunEvents(testRunRequest); this.testPlatformEventSource.ExecutionRequestStart(); testRunRequest.ExecuteAsync(); // Wait for the run completion event testRunRequest.WaitForCompletion(); } finally { this.testLoggerManager.UnregisterTestRunEvents(testRunRequest); this.testRunResultAggregator.UnregisterTestRunEvents(testRunRequest); testRunEventsRegistrar?.UnregisterTestRunEvents(testRunRequest); } } } catch (Exception ex) { EqtTrace.Error("TestRequestManager.RunTests: failed to run tests: {0}", ex); if (ex is TestPlatformException || ex is SettingsException || ex is InvalidOperationException) { LoggerUtilities.RaiseTestRunError(this.testLoggerManager, this.testRunResultAggregator, ex); success = false; } else { throw; } } this.currentTestRunRequest = null; return(success); } }
/// <summary> /// Returns the given pending change if it should be undone, otherwise null. /// </summary> private Task <PendingChange> ShouldUndoPendingChangeAsync(PendingChange pendingChange) { return(Task.Run(() => { if (pendingChange.IsAdd || pendingChange.IsDelete || pendingChange.IsLocalItemDelete || pendingChange.IsUndelete) { return null; } byte[] baseItemHashCode; try { using (var baseFileStream = pendingChange.DownloadBaseFile()) { using (var hashAlgorithem = new SHA1Cng()) { baseItemHashCode = hashAlgorithem.ComputeHash(baseFileStream); } } } catch (Exception ex) { const string ErrorMessageFormat = "Error occurred during computing hash for the base item of {0}: {1}"; LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, pendingChange.ServerItem, ex.ToString())); return null; } byte[] localItemHashCode; try { using (var localFileStream = new FileStream(Path.GetFullPath(pendingChange.LocalItem), FileMode.Open, FileAccess.Read)) { using (var hashAlgorithem = new SHA1Cng()) { localItemHashCode = hashAlgorithem.ComputeHash(localFileStream); } } } catch (Exception ex) { const string ErrorMessageFormat = "Error occurred during computing hash for the local item of {0}: {1}"; LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, pendingChange.ServerItem, ex.ToString())); return null; } return Enumerable.SequenceEqual(baseItemHashCode, localItemHashCode) ? pendingChange : null; })); }
/// <summary> /// Initialize blame. /// </summary> /// <param name="enableDump">Enable dump.</param> /// <param name="blameParameters">Blame parameters.</param> private void InitializeBlame(bool enableDump, Dictionary <string, string> collectDumpParameters) { // Add Blame Logger LoggerUtilities.AddLoggerToRunSettings(BlameFriendlyName, null, this.runSettingsManager); // Add Blame Data Collector CollectArgumentExecutor.AddDataCollectorToRunSettings(BlameFriendlyName, this.runSettingsManager, this.fileHelper); // Add default run settings if required. if (this.runSettingsManager.ActiveRunSettings?.SettingsXml == null) { this.runSettingsManager.AddDefaultRunSettings();; } var settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml; // Get results directory from RunSettingsManager var resultsDirectory = GetResultsDirectory(settings); // Get data collection run settings. Create if not present. var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings); if (dataCollectionRunSettings == null) { dataCollectionRunSettings = new DataCollectionRunSettings(); } // Create blame configuration element. var XmlDocument = new XmlDocument(); var outernode = XmlDocument.CreateElement("Configuration"); var node = XmlDocument.CreateElement("ResultsDirectory"); outernode.AppendChild(node); node.InnerText = resultsDirectory; // Add collect dump node in configuration element. if (enableDump) { AddCollectDumpNode(collectDumpParameters, XmlDocument, outernode); } // Add blame configuration element to blame collector. foreach (var item in dataCollectionRunSettings.DataCollectorSettingsList) { if (item.FriendlyName.Equals(BlameFriendlyName)) { item.Configuration = outernode; } } // Update run settings. runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml); }
/// <summary> /// Initializes with the argument that was provided with the command. /// </summary> /// <param name="argument">Argument that was provided with the command.</param> public void Initialize(string argument) { if (string.IsNullOrWhiteSpace(argument)) { HandleInvalidArgument(argument); } else { string loggerIdentifier = null; Dictionary <string, string> parameters = null; var parseSucceeded = LoggerUtilities.TryParseLoggerArgument(argument, out loggerIdentifier, out parameters); if (parseSucceeded) { if (loggerIdentifier.Equals(ConsoleLogger.FriendlyName, StringComparison.OrdinalIgnoreCase)) { this.loggerManager.AddLogger(new ConsoleLogger(), ConsoleLogger.ExtensionUri, parameters); } else { // First assume the logger is specified by URI. If that fails try with friendly name. try { this.AddLoggerByUri(loggerIdentifier, parameters); } catch (CommandLineException) { string loggerUri; if (this.loggerManager.TryGetUriFromFriendlyName(loggerIdentifier, out loggerUri)) { this.AddLoggerByUri(loggerUri, parameters); } else { throw new CommandLineException( String.Format( CultureInfo.CurrentUICulture, CommandLineResources.LoggerNotFound, argument)); } } } } else { HandleInvalidArgument(argument); } } }
internal static void Log(LogType logType, string message, bool logToConsole = true, bool logToFile = true, bool logToDb = false) { if (!_initialized) { Console.WriteLine("The logger must be initialized"); return; } if (!LoggerUtilities.CanBeLogged(logType)) { return; } Core.Core.Log(logType, message, logToConsole, logToFile, logToDb, _context); }
private bool RunTests(TestRunCriteria testRunCriteria, ITestRunEventsRegistrar testRunEventsRegistrar) { bool success = true; using (this.currentTestRunRequest = this.testPlatform.CreateTestRunRequest(testRunCriteria)) { this.runRequestCreatedEventHandle.Set(); try { this.testLoggerManager.RegisterTestRunEvents(this.currentTestRunRequest); this.testRunResultAggregator.RegisterTestRunEvents(this.currentTestRunRequest); testRunEventsRegistrar?.RegisterTestRunEvents(this.currentTestRunRequest); this.testPlatformEventSource.ExecutionRequestStart(); this.currentTestRunRequest.ExecuteAsync(); // Wait for the run completion event this.currentTestRunRequest.WaitForCompletion(); this.testPlatformEventSource.ExecutionRequestStop(); } catch (Exception ex) { if (ex is TestPlatformException || ex is SettingsException || ex is InvalidOperationException) { LoggerUtilities.RaiseTestRunError(this.testLoggerManager, this.testRunResultAggregator, ex); success = false; } else { throw; } } finally { this.testLoggerManager.UnregisterTestRunEvents(this.currentTestRunRequest); this.testRunResultAggregator.UnregisterTestRunEvents(this.currentTestRunRequest); testRunEventsRegistrar?.UnregisterTestRunEvents(this.currentTestRunRequest); } } this.currentTestRunRequest = null; return(success); }
public sealed override async Task ExecuteAsync(ProjectItem projectItem) { const int MAX_RETRY = 5; const int E_FAIL = unchecked ((int)0x80004005); const int RPC_E_CALL_REJECTED = unchecked ((int)0x80010001); if (projectItem != null) { var statusBar = _serviceProvider.GetService(typeof(SVsStatusbar)) as IVsStatusbar; statusBar.SetText("Updating " + projectItem.get_FileNames(1)); for (int retry = 0; retry < MAX_RETRY; retry++) { try { projectItem.Document.DTE.ExecuteCommand(_command); break; } catch (Exception ex) { if (ex is COMException && (((COMException)ex).ErrorCode == E_FAIL || ((COMException)ex).ErrorCode == RPC_E_CALL_REJECTED) && retry < MAX_RETRY - 1) { await Task.Delay(TimeSpan.FromSeconds(1)); continue; } else { const string ErrorMessageFormat = "Error occurred during the command {0} running on the item {1}: {2}"; LoggerUtilities.LogError(string.Format(CultureInfo.CurrentCulture, ErrorMessageFormat, _command, projectItem.get_FileNames(1), ex.ToString())); break; } } } } }
/// <summary> /// Save Log to a database. Settings needed in app.config for connectivity /// </summary> /// <param name="loglevel">Depends on the severity of the log</param> /// <param name="message">Any text the user would like to add</param> /// <param name="exception">Can be null, when logging in trace or debug mode</param> /// <returns>Boolean for unit test purpose</returns> private Boolean Database(LogObject loglevel, String message, Exception exception = null) { Boolean response = false; try { if (message == null || message.Length == 0 || loglevel == null) { return(response); } LoggerUtilities.GetLogObject(loglevel, message, exception); response = logDao.LogSave(loglevel); } catch (Exception ex) { LoggerUtilities.ShowUnexpectedError("database", ex); } return(response); }
/// <summary> /// Show Log in console /// </summary> /// <param name="logLevel">Depends on the severity of the log</param> /// <param name="message">Any text the user would like to add</param> /// <param name="exception">Can be null, when logging in trace or debug mode</param> /// <returns>Boolean for unit test purpose</returns> private Boolean Console(LogObject logLevel, String message, Exception exception = null) { Boolean response = false; try { if (message == null || message.Length == 0 || logLevel == null) { return(response); } LoggerUtilities.GetLogObject(logLevel, message, exception); String logMessage = LoggerUtilities.FormatLogMessage(logLevel); System.Console.ForegroundColor = logLevel.Level.Color; System.Console.WriteLine(logMessage); response = true; } catch (Exception ex) { LoggerUtilities.ShowUnexpectedError("console", ex); } return(response); }
/// <summary> /// Send message for selected log files. /// </summary> /// <param name="email"></param> /// <param name="subject"></param> /// <param name="text"></param> /// <param name="selectedFiles"></param> public static void SendSelectedLogFiles(string email, string subject, string text, List <object> selectedFiles) { FileInfo[] filesList = LoggerUtilities.GetSelectedLogFiles(selectedFiles); SendLogFiles(email, subject, text, filesList); }
/// <summary> /// Add logger to runsettings. /// </summary> /// <param name="loggerArgument"></param> /// <param name="runSettingsManager"></param> public static void AddLoggerToRunSettings(string loggerArgument, IRunSettingsProvider runSettingsManager) { if (string.IsNullOrWhiteSpace(loggerArgument)) { HandleInvalidArgument(loggerArgument); } var settings = runSettingsManager.ActiveRunSettings?.SettingsXml; if (settings == null) { runSettingsManager.AddDefaultRunSettings(); settings = runSettingsManager.ActiveRunSettings?.SettingsXml; } var loggerRunSettings = XmlRunSettingsUtilities.GetLoggerRunSettings(settings) ?? new LoggerRunSettings(); string loggerIdentifier = null; Dictionary <string, string> parameters = null; var parseSucceeded = LoggerUtilities.TryParseLoggerArgument(loggerArgument, out loggerIdentifier, out parameters); if (parseSucceeded) { var logger = default(LoggerSettings); try { // Logger as uri in command line. var loggerUri = new Uri(loggerIdentifier); logger = new LoggerSettings { Uri = loggerUri, IsEnabled = true }; } catch (UriFormatException) { // Logger as friendlyName in command line. logger = new LoggerSettings { FriendlyName = loggerIdentifier, IsEnabled = true }; } // Converting logger console params to Configuration element if (parameters != null && parameters.Count > 0) { var XmlDocument = new XmlDocument(); var outerNode = XmlDocument.CreateElement("Configuration"); foreach (KeyValuePair <string, string> entry in parameters) { var node = XmlDocument.CreateElement(entry.Key); node.InnerText = entry.Value; outerNode.AppendChild(node); } logger.Configuration = outerNode; } // Remove existing logger. var existingLoggerIndex = loggerRunSettings.GetExistingLoggerIndex(logger); if (existingLoggerIndex >= 0) { loggerRunSettings.LoggerSettingsList.RemoveAt(existingLoggerIndex); } loggerRunSettings.LoggerSettingsList.Add(logger); } else { HandleInvalidArgument(loggerArgument); } runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.LoggerRunSettingsName, loggerRunSettings.ToXml().InnerXml); }
private bool UpdateRunSettingsIfRequired(string runsettingsXml, List <string> sources, out string updatedRunSettingsXml) { bool settingsUpdated = false; updatedRunSettingsXml = runsettingsXml; IDictionary <string, Architecture> sourcePlatforms = new Dictionary <string, Architecture>(); IDictionary <string, Framework> sourceFrameworks = new Dictionary <string, Framework>(); if (!string.IsNullOrEmpty(runsettingsXml)) { // TargetFramework is full CLR. Set DesignMode based on current context. using (var stream = new StringReader(runsettingsXml)) using (var reader = XmlReader.Create(stream, XmlRunSettingsUtilities.ReaderSettings)) { var document = new XmlDocument(); document.Load(reader); var navigator = document.CreateNavigator(); var inferedFramework = inferHelper.AutoDetectFramework(sources, sourceFrameworks); Framework chosenFramework; var inferedPlatform = inferHelper.AutoDetectArchitecture(sources, sourcePlatforms); Architecture chosenPlatform; // Update frmaework and platform if required. For commandline scenario update happens in ArgumentProcessor. bool updateFramework = IsAutoFrameworkDetectRequired(navigator, out chosenFramework); bool updatePlatform = IsAutoPlatformDetectRequired(navigator, out chosenPlatform); if (updateFramework) { InferRunSettingsHelper.UpdateTargetFramework(document, inferedFramework?.ToString(), overwrite: true); chosenFramework = inferedFramework; settingsUpdated = true; } if (updatePlatform) { InferRunSettingsHelper.UpdateTargetPlatform(document, inferedPlatform.ToString(), overwrite: true); chosenPlatform = inferedPlatform; settingsUpdated = true; } var compatibleSources = InferRunSettingsHelper.FilterCompatibleSources(chosenPlatform, chosenFramework, sourcePlatforms, sourceFrameworks, out var incompatibleSettingWarning); if (!string.IsNullOrEmpty(incompatibleSettingWarning)) { EqtTrace.Info(incompatibleSettingWarning); LoggerUtilities.RaiseTestRunWarning(this.testLoggerManager, this.testRunResultAggregator, incompatibleSettingWarning); } if (EqtTrace.IsInfoEnabled) { EqtTrace.Info("Compatible sources list : "); EqtTrace.Info(string.Join("\n", compatibleSources.ToArray())); } // If user is already setting DesignMode via runsettings or CLI args; we skip. var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettingsXml); if (!runConfiguration.DesignModeSet) { InferRunSettingsHelper.UpdateDesignMode(document, this.commandLineOptions.IsDesignMode); settingsUpdated = true; } if (!runConfiguration.CollectSourceInformationSet) { InferRunSettingsHelper.UpdateCollectSourceInformation(document, this.commandLineOptions.ShouldCollectSourceInformation); settingsUpdated = true; } if (InferRunSettingsHelper.TryGetDeviceXml(navigator, out string deviceXml)) { InferRunSettingsHelper.UpdateTargetDevice(document, deviceXml); settingsUpdated = true; } updatedRunSettingsXml = navigator.OuterXml; } } return(settingsUpdated); }
/// <summary> /// Discover Tests given a list of sources, run settings. /// </summary> /// <param name="discoveryPayload">Discovery payload</param> /// <param name="discoveryEventsRegistrar">EventHandler for discovered tests</param> /// <param name="protocolConfig">Protocol related information</param> /// <returns>True, if successful</returns> public bool DiscoverTests(DiscoveryRequestPayload discoveryPayload, ITestDiscoveryEventsRegistrar discoveryEventsRegistrar, ProtocolConfig protocolConfig) { EqtTrace.Info("TestRequestManager.DiscoverTests: Discovery tests started."); bool success = false; var runsettings = discoveryPayload.RunSettings; if (discoveryPayload.TestPlatformOptions != null) { this.telemetryOptedIn = discoveryPayload.TestPlatformOptions.CollectMetrics; } var requestData = this.GetRequestData(protocolConfig); if (this.UpdateRunSettingsIfRequired(runsettings, discoveryPayload.Sources?.ToList(), out string updatedRunsettings)) { runsettings = updatedRunsettings; } var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runsettings); var batchSize = runConfiguration.BatchSize; if (requestData.IsTelemetryOptedIn) { // Collect Metrics this.CollectMetrics(requestData, runConfiguration); // Collect Commands this.LogCommandsTelemetryPoints(requestData); } // create discovery request var criteria = new DiscoveryCriteria(discoveryPayload.Sources, batchSize, this.commandLineOptions.TestStatsEventTimeout, runsettings); criteria.TestCaseFilter = this.commandLineOptions.TestCaseFilterValue; try { using (IDiscoveryRequest discoveryRequest = this.testPlatform.CreateDiscoveryRequest(requestData, criteria)) { try { this.testLoggerManager?.RegisterDiscoveryEvents(discoveryRequest); discoveryEventsRegistrar?.RegisterDiscoveryEvents(discoveryRequest); this.testPlatformEventSource.DiscoveryRequestStart(); discoveryRequest.DiscoverAsync(); discoveryRequest.WaitForCompletion(); success = true; } finally { this.testLoggerManager?.UnregisterDiscoveryEvents(discoveryRequest); discoveryEventsRegistrar?.UnregisterDiscoveryEvents(discoveryRequest); } } } catch (Exception ex) { if (ex is TestPlatformException || ex is SettingsException || ex is InvalidOperationException) { LoggerUtilities.RaiseTestRunError(testLoggerManager, null, ex); success = false; } else { throw; } } EqtTrace.Info("TestRequestManager.DiscoverTests: Discovery tests completed, successful: {0}.", success); this.testPlatformEventSource.DiscoveryRequestStop(); // Posts the Discovery Complete event. this.metricsPublisher.Result.PublishMetrics(TelemetryDataConstants.TestDiscoveryCompleteEvent, requestData.MetricsCollection.Metrics); return(success); }
public LoggerDao() { _connection = LoggerUtilities.GetConnection(); }
// Delete logs methods #region DeleteAllLogFiles /// <summary> /// Delete all log files. /// </summary> public static void DeleteAllLogFiles() { FileInfo[] filesList = LoggerUtilities.GetAllLogFiles(); LoggerUtilities.DeleteLogFiles(filesList); }
/// <summary> /// Initialize blame. /// </summary> /// <param name="enableCrashDump">Enable dump.</param> /// <param name="blameParameters">Blame parameters.</param> private void InitializeBlame(bool enableCrashDump, bool enableHangDump, Dictionary <string, string> collectDumpParameters) { // Add Blame Logger LoggerUtilities.AddLoggerToRunSettings(BlameFriendlyName, null, this.runSettingsManager); // Add Blame Data Collector CollectArgumentExecutor.AddDataCollectorToRunSettings(BlameFriendlyName, this.runSettingsManager, this.fileHelper); // Add default run settings if required. if (this.runSettingsManager.ActiveRunSettings?.SettingsXml == null) { this.runSettingsManager.AddDefaultRunSettings();; } var settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml; // Get results directory from RunSettingsManager var resultsDirectory = GetResultsDirectory(settings); // Get data collection run settings. Create if not present. var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings); if (dataCollectionRunSettings == null) { dataCollectionRunSettings = new DataCollectionRunSettings(); } // Create blame configuration element. var XmlDocument = new XmlDocument(); var outernode = XmlDocument.CreateElement("Configuration"); var node = XmlDocument.CreateElement("ResultsDirectory"); outernode.AppendChild(node); node.InnerText = resultsDirectory; // Add collect dump node in configuration element. if (enableCrashDump) { var dumpParameters = collectDumpParameters .Where(p => new[] { "CollectAlways", "DumpType" }.Contains(p.Key)) .ToDictionary(p => p.Key, p => p.Value); if (!dumpParameters.ContainsKey("DumpType")) { dumpParameters.Add("DumpType", "Full"); } AddCollectDumpNode(dumpParameters, XmlDocument, outernode); } // Add collect hang dump node in configuration element. if (enableHangDump) { var hangDumpParameters = collectDumpParameters .Where(p => new[] { "TestTimeout", "HangDumpType" }.Contains(p.Key)) .ToDictionary(p => p.Key, p => p.Value); if (!hangDumpParameters.ContainsKey("TestTimeout")) { hangDumpParameters.Add("TestTimeout", TimeSpan.FromHours(1).TotalMilliseconds.ToString()); } if (!hangDumpParameters.ContainsKey("HangDumpType")) { hangDumpParameters.Add("HangDumpType", "Full"); } AddCollectHangDumpNode(hangDumpParameters, XmlDocument, outernode); } // Add blame configuration element to blame collector. foreach (var item in dataCollectionRunSettings.DataCollectorSettingsList) { if (item.FriendlyName.Equals(BlameFriendlyName)) { item.Configuration = outernode; } } // Update run settings. runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml); }
/// <summary> /// Delete selected log files. /// </summary> /// <param name="selectedFiles"></param> public static void DeleteSelectedLogFiles(List <object> selectedFiles) { FileInfo[] filesList = LoggerUtilities.GetSelectedLogFiles(selectedFiles); LoggerUtilities.DeleteLogFiles(filesList); }
/// <summary> /// Delete log files, older than specified date. /// </summary> /// <param name="olderThanDate"></param> public static void DeleteOlderLogFiles(DateTime olderThanDate) { FileInfo[] filesList = LoggerUtilities.GetOlderLogFiles(olderThanDate); LoggerUtilities.DeleteLogFiles(filesList); }
/// <summary> /// Send message for log files, older than specified date. /// </summary> /// <param name="email"></param> /// <param name="subject"></param> /// <param name="text"></param> /// <param name="olderThanDate"></param> public static void SendOlderLogFiles(string email, string subject, string text, DateTime olderThanDate) { FileInfo[] filesList = LoggerUtilities.GetOlderLogFiles(olderThanDate); SendLogFiles(email, subject, text, filesList); }
// Send logs methods #region SendAllLogFiles /// <summary> /// Send message for all log files. /// </summary> /// <param name="email"></param> /// <param name="subject"></param> /// <param name="text"></param> public static void SendAllLogFiles(string email, string subject, string text) { FileInfo[] filesList = LoggerUtilities.GetAllLogFiles(); SendLogFiles(email, subject, text, filesList); }