/// <summary>
/// Log Enabled Data Collectors
/// </summary>
private void LogEnabledDataCollectors()
{
if (!this.requestData.IsTelemetryOptedIn)
{
return;
}
var dataCollectionSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(this.SettingsXml);
if (dataCollectionSettings == null || !dataCollectionSettings.IsCollectionEnabled)
{
return;
}
var enabledDataCollectors = new List <DataCollectorSettings>();
foreach (var settings in dataCollectionSettings.DataCollectorSettingsList)
{
if (settings.IsEnabled)
{
if (enabledDataCollectors.Any(dcSettings => string.Equals(dcSettings.FriendlyName, settings.FriendlyName, StringComparison.OrdinalIgnoreCase)))
{
// If Uri or assembly qualified type name is repeated, consider data collector as duplicate and ignore it.
continue;
}
enabledDataCollectors.Add(settings);
}
}
var dataCollectors = enabledDataCollectors.Select(x => new { x.FriendlyName, x.Uri }.ToString());
this.requestData.MetricsCollection.Add(TelemetryDataConstants.DataCollectorsEnabled, string.Join(",", dataCollectors.ToArray()));
}
internal static void AddDataCollectorToRunSettings(string argument, IRunSettingsProvider runSettingsManager)
{
EnabledDataCollectors.Add(argument.ToLower());
var settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
if (settings == null)
{
runSettingsManager.AddDefaultRunSettings();
settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
else
{
// By default, all data collectors present in run settings are enabled, if enabled attribute is not specified.
// So explicitely disable those data collectors and enable those which are specified.
DisableUnConfiguredDataCollectors(dataCollectionRunSettings);
}
// Add data collectors if not already present, enable if already present.
EnableDataCollectorUsingFriendlyName(argument, dataCollectionRunSettings);
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
/// <summary>
/// The get data collector launcher.
/// </summary>
/// <returns>
/// The <see cref="IDataCollectionLauncher"/>.
/// </returns>
internal static IDataCollectionLauncher GetDataCollectorLauncher(IProcessHelper processHelper, string settingsXml)
{
// Always launch datacollector.exe if code coverage is configured.
if (!string.IsNullOrWhiteSpace(settingsXml))
{
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settingsXml);
foreach (var dataCollectorSettings in dataCollectionRunSettings.DataCollectorSettingsList)
{
if (string.Equals(dataCollectorSettings.FriendlyName, "event Log", StringComparison.OrdinalIgnoreCase) || string.Equals(dataCollectorSettings.Uri?.ToString(), @"datacollector://Microsoft/EventLog/2.0", StringComparison.OrdinalIgnoreCase))
{
return(new DefaultDataCollectionLauncher());
}
}
}
// Target Framework of DataCollection process and Runner should be same.
var currentProcessPath = processHelper.GetCurrentProcessFileName();
if (currentProcessPath.EndsWith("dotnet", StringComparison.OrdinalIgnoreCase) ||
currentProcessPath.EndsWith("dotnet.exe", StringComparison.OrdinalIgnoreCase))
{
return(new DotnetDataCollectionLauncher());
}
return(new DefaultDataCollectionLauncher());
}
internal static void AddDataCollectorToRunSettings(string argument, IRunSettingsProvider runSettingsManager, IFileHelper fileHelper)
{
EnabledDataCollectors.Add(argument.ToLower());
var settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
if (settings == null)
{
runSettingsManager.AddDefaultRunSettings();
settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings) ?? new DataCollectionRunSettings();
var inProcDataCollectionRunSettings = XmlRunSettingsUtilities.GetInProcDataCollectionRunSettings(settings)
?? new DataCollectionRunSettings(
Constants.InProcDataCollectionRunSettingsName,
Constants.InProcDataCollectorsSettingName,
Constants.InProcDataCollectorSettingName);
// Add data collectors if not already present, enable if already present.
EnableDataCollectorUsingFriendlyName(argument, dataCollectionRunSettings);
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
if (string.Equals(argument, CoverletConstants.CoverletDataCollectorFriendlyName, StringComparison.OrdinalIgnoreCase))
{
// Add in-proc data collector to runsettings if coverlet code coverage is enabled
EnableCoverletInProcDataCollector(argument, inProcDataCollectionRunSettings, runSettingsManager, fileHelper);
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.InProcDataCollectionRunSettingsName, inProcDataCollectionRunSettings.ToXml().InnerXml);
}
}
/// <inheritdoc/>
public IDictionary <string, string> InitializeDataCollectors(string settingsXml)
{
if (string.IsNullOrEmpty(settingsXml) && EqtTrace.IsInfoEnabled)
{
EqtTrace.Info("DataCollectionManager.InitializeDataCollectors : Runsettings is null or empty.");
}
ValidateArg.NotNull(settingsXml, "settingsXml");
var sessionId = new SessionId(Guid.NewGuid());
var dataCollectionContext = new DataCollectionContext(sessionId);
this.dataCollectionEnvironmentContext = DataCollectionEnvironmentContext.CreateForLocalEnvironment(dataCollectionContext);
this.attachmentManager.Initialize(sessionId, sourceDirectory, this.messageSink);
// Enviornment variables are passed to testhost process, through ProcessStartInfo.EnvironmentVariables, which handles the key in a case-insensitive manner, which is translated to lowercase.
// Therefore, using StringComparer.OrdinalIgnoreCase so that same keys with different cases are treated as same.
var executionEnvironmentVariables = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
var runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(settingsXml);
sourceDirectory = RunSettingsUtilities.GetTestResultsDirectory(runConfiguration);
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settingsXml);
this.isDataCollectionEnabled = dataCollectionRunSettings.IsCollectionEnabled;
// If dataCollectionRunSettings is null, that means datacollectors are not configured.
if (dataCollectionRunSettings == null || !dataCollectionRunSettings.IsCollectionEnabled)
{
return(executionEnvironmentVariables);
}
// Get settings for each data collector, load and initialize the data collectors.
var enabledDataCollectorsSettings = this.GetDataCollectorsEnabledForRun(dataCollectionRunSettings);
if (enabledDataCollectorsSettings == null || enabledDataCollectorsSettings.Count == 0)
{
return(executionEnvironmentVariables);
}
foreach (var dataCollectorSettings in enabledDataCollectorsSettings)
{
this.LoadAndInitialize(dataCollectorSettings);
}
// Once all data collectors have been initialized, query for environment variables
bool unloadedAnyCollector;
var dataCollectorEnvironmentVariables = this.GetEnvironmentVariables(out unloadedAnyCollector);
foreach (var variable in dataCollectorEnvironmentVariables.Values)
{
executionEnvironmentVariables.Add(variable.Name, variable.Value);
}
return(executionEnvironmentVariables);
}
/// <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);
}
protected virtual DataCollectorSettings ParseRunSettings(string runSettingsFile)
{
try
{
using FileStream settingsFileStream = new FileStream(runSettingsFile, FileMode.Open);
using StreamReader reader = new StreamReader(settingsFileStream);
string xml = reader.ReadToEnd();
DataCollectionRunSettings runSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(xml);
return(runSettings.DataCollectorSettingsList.FirstOrDefault(
s => s.FriendlyName == provider.RunSettingsDataCollectorFriendlyName && s.IsEnabled));
} catch
{
return(null);
}
}
/// <inheritdoc />
public void Initialize(string argument)
{
// 1. Disable all other data collectors. Enable only those data collectors that are explicitely specified by user.
// 2. Check if Code Coverage Data Collector is specified in runsettings, if not add it and also set enable to true.
// if argument is null or doesn't contain any element, don't do anything.
if (string.IsNullOrWhiteSpace(argument))
{
throw new CommandLineException(
string.Format(
CultureInfo.CurrentUICulture,
CommandLineResources.DataCollectorFriendlyNameInvalid,
argument));
}
EnabledDataCollectors.Add(argument.ToLower());
var settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml;
if (settings == null)
{
this.runSettingsManager.AddDefaultRunSettings();
settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
else
{
// By default, all data collectors present in run settings are enabled, if enabled attribute is not specified.
// So explicitely disable those data collectors and enable those which are specified.
DisableUnConfiguredDataCollectors(dataCollectionRunSettings);
}
// Add data collectors if not already present, enable if already present.
EnableDataCollectorUsingFriendlyName(argument, dataCollectionRunSettings);
this.runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
internal static void AddDataCollectorToRunSettings(string argument, IRunSettingsProvider runSettingsManager)
{
EnabledDataCollectors.Add(argument.ToLower());
var settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
if (settings == null)
{
runSettingsManager.AddDefaultRunSettings();
settings = runSettingsManager.ActiveRunSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
// Add data collectors if not already present, enable if already present.
EnableDataCollectorUsingFriendlyName(argument, dataCollectionRunSettings);
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
/// <inheritdoc />
public void Initialize(string argument)
{
// Add this enabled data collectors list, this will ensure Code Coverage isn't disabled when other DCs are configured using /Collect.
CollectArgumentExecutor.EnabledDataCollectors.Add(FriendlyName.ToLower());
var settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml;
if (settings == null)
{
this.runSettingsManager.AddDefaultRunSettings();
settings = this.runSettingsManager.ActiveRunSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
CollectArgumentExecutor.EnableDataCollectorUsingFriendlyName(FriendlyName, dataCollectionRunSettings);
this.runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
public void GetDataCollectionRunSettingsShouldThrowOnMalformedDataCollectorSettings()
{
Assert.ThrowsException <SettingsException>(() => XmlRunSettingsUtilities.GetDataCollectionRunSettings(this.runSettingsXmlWithIncorrectDataCollectorSettings));
}
public void GetDataCollectionRunSettingsShouldReturnDataCollectorRunSettingsEvenIfDisabled()
{
Assert.IsNotNull(XmlRunSettingsUtilities.GetDataCollectionRunSettings(this.runSettingsXmlWithDataCollectorsDisabled));
}
public void GetDataCollectionRunSettingsShouldReturnNullOnNoDataCollectorSettings()
{
Assert.IsNull(XmlRunSettingsUtilities.GetDataCollectionRunSettings("<RunSettings></RunSettings>"));
}
public void GetDataCollectionRunSettingsShouldReturnNullIfSettingsIsNull()
{
Assert.IsNull(XmlRunSettingsUtilities.GetDataCollectionRunSettings(null));
}
/// <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)
{
bool isDumpEnabled = false;
if (!string.IsNullOrWhiteSpace(argument) && argument.Equals(Constants.BlameCollectDumpKey, StringComparison.OrdinalIgnoreCase))
{
if (this.environment.OperatingSystem == PlatformOperatingSystem.Windows &&
this.environment.Architecture != PlatformArchitecture.ARM64 &&
this.environment.Architecture != PlatformArchitecture.ARM)
{
isDumpEnabled = true;
}
else
{
Output.Warning(false, CommandLineResources.BlameCollectDumpNotSupportedForPlatform);
}
}
// Add Blame Logger
EnableLoggerArgumentExecutor.AddLoggerToRunSettings(BlameFriendlyName, this.runSettingsManager);
// Add Blame Data Collector
CollectArgumentExecutor.AddDataCollectorToRunSettings(BlameFriendlyName, this.runSettingsManager);
// Get results directory from RunSettingsManager
var runSettings = this.runSettingsManager.ActiveRunSettings;
string resultsDirectory = null;
if (runSettings != null)
{
try
{
RunConfiguration runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runSettings.SettingsXml);
resultsDirectory = RunSettingsUtilities.GetTestResultsDirectory(runConfiguration);
}
catch (SettingsException se)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("EnableBlameArgumentProcessor: Unable to get the test results directory: Error {0}", se);
}
}
}
// Add configuration element
var settings = runSettings?.SettingsXml;
if (settings == null)
{
runSettingsManager.AddDefaultRunSettings();
settings = runSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
var XmlDocument = new XmlDocument();
var outernode = XmlDocument.CreateElement("Configuration");
var node = XmlDocument.CreateElement("ResultsDirectory");
outernode.AppendChild(node);
node.InnerText = resultsDirectory;
if (isDumpEnabled)
{
var dumpNode = XmlDocument.CreateElement(Constants.BlameCollectDumpKey);
outernode.AppendChild(dumpNode);
}
foreach (var item in dataCollectionRunSettings.DataCollectorSettingsList)
{
if (item.FriendlyName.Equals(BlameFriendlyName))
{
item.Configuration = outernode;
}
}
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
/// <summary>
/// Validates the collectors in runsettings when an in-lined testsettings is specified
/// </summary>
/// <param name="runsettings">RunSettings used for the run</param>
/// <returns>True if an incompatible collector is found</returns>
public static bool AreRunSettingsCollectorsInCompatibleWithTestSettings(string runsettings)
{
// If there's no embedded testsettings.. bail out
if (!IsTestSettingsEnabled(runsettings))
{
return(false);
}
// Explicitly blocking usage of data collectors through modes runsettings and testsettings except
// for couple of scenarios where the IDE generates the collector settings in the runsettings file even when
// it has an embedded testsettings file. Longterm runsettings will be the single run configuration source
// In-proc collectors are incompatible with testsettings
var inprocDataCollectionSettings = XmlRunSettingsUtilities.GetInProcDataCollectionRunSettings(runsettings);
if (inprocDataCollectionSettings != null && inprocDataCollectionSettings.IsCollectionEnabled && inprocDataCollectionSettings.DataCollectorSettingsList != null)
{
foreach (var collectorSettings in inprocDataCollectionSettings.DataCollectorSettingsList)
{
if (collectorSettings.IsEnabled)
{
EqtTrace.Warning($"Incompatible collector found. {collectorSettings.FriendlyName} : {collectorSettings.Uri}");
return(true);
}
}
}
// TestSettings and collection is enabled in runsetttings.. the only allowed collectors are code coverage and fakes
var datacollectionSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(runsettings);
if (datacollectionSettings != null && datacollectionSettings.IsCollectionEnabled && datacollectionSettings.DataCollectorSettingsList != null)
{
foreach (var collectorRef in datacollectionSettings.DataCollectorSettingsList)
{
// Ignore disabled collector
if (!collectorRef.IsEnabled)
{
continue;
}
// If the configured collector is code coverage or fakes.. ignore
if (!string.IsNullOrWhiteSpace(collectorRef.FriendlyName) &&
(FakesFriendlyName.Equals(collectorRef.FriendlyName, StringComparison.OrdinalIgnoreCase) ||
CodeCoverageFriendlyName.Equals(collectorRef.FriendlyName, StringComparison.OrdinalIgnoreCase)))
{
continue;
}
// If the configured collector is code coverage or fakes.. ignore
if (collectorRef.Uri != null &&
(CodeCoverageCollectorUri.Equals(collectorRef.Uri.ToString(), StringComparison.OrdinalIgnoreCase) ||
FakesCollectorUri.Equals(collectorRef.Uri.ToString(), StringComparison.OrdinalIgnoreCase)))
{
continue;
}
EqtTrace.Warning($"Incompatible collector found. {collectorRef.FriendlyName} : {collectorRef.Uri}");
return(true);
}
}
return(false);
}
/// <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>
/// 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)
{
// Add Blame Logger
this.loggerManager.UpdateLoggerList(BlameFriendlyName, BlameFriendlyName, null);
// Add Blame Data Collector
CollectArgumentExecutor.AddDataCollectorToRunSettings(BlameFriendlyName, this.runSettingsManager);
// Get results directory from RunSettingsManager
var runSettings = this.runSettingsManager.ActiveRunSettings;
string resultsDirectory = null;
if (runSettings != null)
{
try
{
RunConfiguration runConfiguration = XmlRunSettingsUtilities.GetRunConfigurationNode(runSettings.SettingsXml);
resultsDirectory = RunSettingsUtilities.GetTestResultsDirectory(runConfiguration);
}
catch (SettingsException se)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("EnableBlameArgumentProcessor: Unable to get the test results directory: Error {0}", se);
}
}
}
// Add configuration element
var settings = runSettings?.SettingsXml;
if (settings == null)
{
runSettingsManager.AddDefaultRunSettings();
settings = runSettings?.SettingsXml;
}
var dataCollectionRunSettings = XmlRunSettingsUtilities.GetDataCollectionRunSettings(settings);
if (dataCollectionRunSettings == null)
{
dataCollectionRunSettings = new DataCollectionRunSettings();
}
var XmlDocument = new XmlDocument();
var outernode = XmlDocument.CreateElement("Configuration");
var node = XmlDocument.CreateElement("ResultsDirectory");
outernode.AppendChild(node);
node.InnerText = resultsDirectory;
foreach (var item in dataCollectionRunSettings.DataCollectorSettingsList)
{
if (item.FriendlyName.Equals(BlameFriendlyName))
{
item.Configuration = outernode;
}
}
runSettingsManager.UpdateRunSettingsNodeInnerXml(Constants.DataCollectionRunSettingsName, dataCollectionRunSettings.ToXml().InnerXml);
}
