private static void ProcessCoverage(PublisherConfiguration config, CancellationToken cancellationToken)
{
// Currently the publisher only works for azure pipelines, so we simply instansiate for Azure Pipelines
AzurePipelinesPublisher publisher = null;
IExecutionContext context = null;
try
{
publisher = new AzurePipelinesPublisher(/*enableTelemetry*/ !config.DisableTelemetry);
context = publisher.ExecutionContext;
TraceLogger.Initialize(context.Logger);
}
catch (Exception ex)
{
Console.Error.Write(string.Format(Resources.CouldNotConnectToAzurePipelines, ex));
return;
}
var processor = new CoverageProcessor(publisher, context.TelemetryDataCollector);
// By default wait for 2 minutes for coverage to publish
var publishTimedout = processor.ParseAndPublishCoverage(config, cancellationToken, new Parser(config, context.TelemetryDataCollector))
.Wait(config.TimeoutInSeconds * 1000, cancellationToken);
if (publishTimedout)
{
_cancellationTokenSource.Cancel();
}
else
{
publishSuccess = true;
}
}
public void WillSafelyLogException()
{
var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
var mockTool = new Mock <ICoverageParserTool>();
Directory.CreateDirectory(tempDir);
mockTool.Setup(x => x.GenerateHTMLReport()).Throws(new Exception("error"));
var config = new PublisherConfiguration()
{
CoverageFiles = new List <string>()
{
"SampleCoverage/Clover.xml", "SampleCoverage/Cobertura.xml", "SampleCoverage/Jacoco.xml"
},
ReportDirectory = tempDir
};
var parser = new TestParser(config, _mockTelemetry.Object);
parser.GenerateReport(mockTool.Object);
//cleanup
Directory.Delete(tempDir, true);
Assert.IsTrue(_logger.Log.Contains($"error: {string.Format(Resources.HTMLReportError, "error")}".Trim()));
}
protected virtual void UpdateExchangeConfig(PublisherConfiguration config, Type messageType)
{
var attribute = GetAttribute <ExchangeAttribute>(messageType);
if (attribute == null)
{
return;
}
if (!string.IsNullOrWhiteSpace(attribute.Name))
{
config.ExchangeName = attribute.Name;
if (config.Exchange != null)
{
config.Exchange.Name = attribute.Name;
}
}
if (config.Exchange == null)
{
return;
}
if (attribute.NullableDurability.HasValue)
{
config.Exchange.Durable = attribute.NullableDurability.Value;
}
if (attribute.NullableAutoDelete.HasValue)
{
config.Exchange.AutoDelete = attribute.NullableAutoDelete.Value;
}
if (attribute.Type != ExchangeType.Unknown)
{
config.Exchange.ExchangeType = attribute.Type.ToString().ToLowerInvariant();
}
}
public void RunBeforeAnyTests()
{
Log.Initializing += Log_Initializing;
m_Configuration = new AgentConfiguration();
PublisherConfiguration publisher = m_Configuration.Publisher;
publisher.ProductName = "NUnit";
publisher.ApplicationName = "Loupe.PerformanceCounters.Tests";
//and now try to get the file version. This is risky.
var fileVersionAttributes = this.GetType().GetTypeInfo().Assembly.GetCustomAttributes(typeof(AssemblyFileVersionAttribute));
if (fileVersionAttributes != null)
{
AssemblyFileVersionAttribute leadAttribute = fileVersionAttributes.FirstOrDefault() as AssemblyFileVersionAttribute;
if (leadAttribute != null)
{
publisher.ApplicationVersion = new Version(leadAttribute.Version);
}
}
publisher.ApplicationDescription = "NUnit tests of the Loupe Agent PerformanceCounter Library";
m_Configuration.SessionFile.EnableFilePruning = false;
Monitor.Subscribe(new PerformanceMonitor(new PerformanceConfiguration()));
//force us to initialize logging
Log.StartSession(m_Configuration);
Trace.TraceInformation("Starting testing at {0} on computer {1}", DateTimeOffset.UtcNow, Log.SessionSummary.HostName);
}
void Log_Initializing(object sender, LogInitializingEventArgs e)
{
if (m_HaveCanceled == false)
{
//we haven't done our first cancel test.
e.Cancel = true;
m_HaveCanceled = true;
}
else
{
//set up our logging.
PublisherConfiguration publisher = e.Configuration.Publisher;
publisher.ProductName = "NUnit";
publisher.ApplicationName = "Gibraltar.Test";
//and now try to get the file version. This is risky.
var fileVersionAttributes = this.GetType().GetTypeInfo().Assembly.GetCustomAttributes(typeof(AssemblyFileVersionAttribute));
if (fileVersionAttributes != null)
{
AssemblyFileVersionAttribute leadAttribute = fileVersionAttributes.FirstOrDefault() as AssemblyFileVersionAttribute;
if (leadAttribute != null)
{
publisher.ApplicationVersion = new Version(leadAttribute.Version);
}
}
publisher.ApplicationDescription = "NUnit tests of the Gibraltar Core Library";
e.Configuration.SessionFile.EnableFilePruning = false;
}
}
public void RunBeforeAnyTests()
{
//delete the existing local logs folder for us...
try
{
var path = Path.Combine(Environment.GetEnvironmentVariable(RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "ProgramData" : "Home"), @"Gibraltar\Local Logs\NUnit");
Directory.Delete(path, true);
}
catch (Exception ex)
{
Trace.TraceWarning("Unable to clean out local logs directory due to " + ex.GetType());
}
Log.Initializing += Log_Initializing;
m_Configuration = new AgentConfiguration();
PublisherConfiguration publisher = m_Configuration.Publisher;
publisher.ProductName = "NUnit";
publisher.ApplicationName = "Gibraltar.Agent.Test";
//and now try to get the file version. This is risky.
var fileVersionAttributes = this.GetType().GetTypeInfo().Assembly.GetCustomAttributes(typeof(AssemblyFileVersionAttribute));
if (fileVersionAttributes != null)
{
AssemblyFileVersionAttribute leadAttribute = fileVersionAttributes.FirstOrDefault() as AssemblyFileVersionAttribute;
if (leadAttribute != null)
{
publisher.ApplicationVersion = new Version(leadAttribute.Version);
}
}
publisher.ApplicationDescription = "NUnit tests of the Loupe Agent Library";
m_Configuration.SessionFile.EnableFilePruning = false;
//if we need email server information set that
#if CONFIGURE_EMAIL
EmailConfiguration email = e.Configuration.Email;
email.Server = EmailServer;
email.Port = EmailServerPort;
email.User = EmailServerUser;
email.Password = EmailServerPassword;
email.UseSsl = EmailUseSsl;
PackagerConfiguration packager = e.Configuration.Packager;
packager.DestinationEmailAddress = EmailToAddress;
packager.FromEmailAddress = EmailFromAddress;
#endif
//force us to initialize logging
Log.StartSession(m_Configuration);
Trace.TraceInformation("Starting testing at {0} on computer {1}", DateTimeOffset.UtcNow, Log.SessionSummary.HostName);
//we have to test this before we get into the application user tests and start manipulating the properties.
Assert.That(Gibraltar.Monitor.Log.PrincipalResolver, Is.InstanceOf(typeof(DefaultPrincipalResolver)));
Assert.That(Log.PrincipalResolver, Is.InstanceOf(typeof(DefaultPrincipalResolver)));
}
public IPublisher <TMessage> CreatePublisher <TMessage>(Action <IPublisherBuilder <TMessage> > builder)
{
var configuration = new PublisherConfiguration <TMessage>();
builder(configuration);
return(CreatePublisher(configuration));
}
protected virtual void UpdateRoutingConfig(PublisherConfiguration config, Type messageType)
{
var routingAttr = GetAttribute <RoutingAttribute>(messageType);
if (routingAttr?.RoutingKey != null)
{
config.RoutingKey = routingAttr.RoutingKey;
}
}
protected override ICoverageParserTool GetCoverageParserTool(PublisherConfiguration config)
{
if (_tool != null)
{
return(_tool);
}
return(base.GetCoverageParserTool(config));
}
public Parser(PublisherConfiguration config, ITelemetryDataCollector telemetry)
{
_configuration = config;
_telemetry = telemetry;
using (new SimpleTimer("Parser", "Parsing", _telemetry))
{
_coverageParserTool = new Lazy <ICoverageParserTool>(() => this.GetCoverageParserTool(_configuration));
}
}
/// <summary>
/// Initializes a new <see cref="Publisher" \> instance.
/// </summary>
///
/// <param name="testConfiguration">The <see cref="TestConfiguration" /> used to configure the processor test scenario run.</param>
/// <param name="publisherConfiguration">The <see cref="PublisherConfiguration" /> instance used to configure this instance of <see cref="Publisher" />.</param>
/// <param name="metrics">The <see cref="Metrics" /> instance used to send metrics to Application Insights.</param>
/// <param name="testName">The name of the test being run in order to organize metrics being collected.</param>
///
public Publisher(PublisherConfiguration publisherConfiguration,
TestConfiguration testConfiguration,
Metrics metrics,
string testName)
{
_testConfiguration = testConfiguration;
_publisherconfiguration = publisherConfiguration;
_metrics = metrics;
_testName = testName;
}
public BlobPublisherRepository(PublisherConfiguration configuration, ILoggerWrapper logger)
{
_configuration = configuration;
_logger = logger;
var storageAccount = CloudStorageAccount.Parse(configuration.StorageConnectionString);
var blobClient = storageAccount.CreateCloudBlobClient();
_container = blobClient.GetContainerReference(configuration.StorageContainerName);
}
public ReportGeneratorTool(PublisherConfiguration configuration)
{
Configuration = configuration;
if (Configuration.CoverageFiles == null)
{
TraceLogger.Debug("ReportGeneratorTool: No input coverage files to parse.");
return;
}
_parserResult = ParseCoverageFiles(new List <string>(Configuration.CoverageFiles));
}
/// <summary>
/// Create a publisher config.
/// </summary>
/// <param name="id">Id of the publisher</param>
/// <param name="endpointId">Id of the end point</param>
/// <param name="transformerId">Id of the transformer</param>
/// <returns>A new config</returns>
public static PublisherConfiguration CreatePublisherConfig(string id, string endpointId, string transformerId)
{
var config = new PublisherConfiguration()
{
Id = id,
Type = TYPE_PUBLISHER,
EndpointId = endpointId,
TransformerId = transformerId
};
return(config);
}
public void WillGenerateReportWhenParsingFileCoverage()
{
var config = new PublisherConfiguration();
var parser = new Mock <TestParser>(config, _mockTelemetry.Object);
parser.Setup(x => x.GenerateReport(It.IsAny <ICoverageParserTool>()));
parser.CallBase = true;
parser.Object.GetFileCoverageInfos();
parser.Verify(x => x.GenerateReport(It.IsAny <ICoverageParserTool>()));
}
public PublisherConfiguration ProcessCommandLineArgs(string[] args)
{
var promise = new TaskCompletionSource <PublisherConfiguration>();
PublisherConfiguration config = null;
Parser.Default.ParseArguments <Options>(args)
.WithParsed <Options>(opts =>
{
config = opts;
});
return(config);
}
/// <summary>
/// Create a publisher.
/// </summary>
/// <param name="type">Fully qualified name of the publisher class</param>
/// <param name="id">Id of the publisher</param>
/// <param name="config">The config parameters for connecting to the data end point</param>
/// <returns>A new publisher</returns>
public static IPublisher CreatePublisher(PublisherConfiguration config, EndPointConfiguration endpointConfig)
{
try
{
var publisher = ComponentRegistration.CreateInstance <IPublisher>(config.Type);
publisher.Configure(config.Id, endpointConfig);
return(publisher);
}
catch (Exception e)
{
_logger.Error(e);
}
return(null);
}
public void CollectorFactory_CreatePublisher_Succeeds()
{
var endpointConfig = CreateEndPointConfig("10", "URI", "http://acme.com/ivanti/uno/discovery");
var config = new PublisherConfiguration()
{
Id = "4",
Type = TYPE_PUBLISHER,
EndpointId = "1",
TransformerId = "4"
};
var handler = new MockTransformationHandler();
var publisher = CollectorFactory.CreatePublisher(config, endpointConfig);
publisher.Should().NotBeNull();
}
public void ParsingException()
{
var mockTool = new Mock <ICoverageParserTool>();
var config = new PublisherConfiguration()
{
};
var parser = new Mock <TestParser>(config, _mockTelemetry.Object, mockTool.Object);
mockTool.Setup(x => x.GetCoverageSummary()).Throws(new Exception("error"));
mockTool.Setup(x => x.GetFileCoverageInfos()).Throws(new Exception("error"));
parser.Setup(x => x.GenerateReport(It.IsAny <ICoverageParserTool>()));
parser.CallBase = true;
Assert.ThrowsException <ParsingException>(() => parser.Object.GetFileCoverageInfos());
Assert.ThrowsException <ParsingException>(() => parser.Object.GetCoverageSummary());
}
/// <summary>
/// Starts a background task for each test that needs to be run, and waits for all
/// test runs to completed before returning.
/// </summary>
///
/// <param name="roleList">The list of roles needed for the scenario being run.</param>
/// <param name="testConfiguration">The <see cref="TestConfiguration" /> instance used to configure this test scenario run.</param>
/// <param name="roleConfiguration">The <see cref="RoleConfiguration" /> instance used to configure the role being run.</param>
/// <param name="metrics">The <see cref="Metrics" /> instance used by this role to send metrics to application insights.</param>
/// <param name="testName">The name of the test scenario that is being run, for metrics purposes.</param>
/// <param name="cancellationToken">The <see cref="CancellationToke"/> instance to signal the request to cancel the operation.</param>
///
private static async Task RunRole(string role,
TestConfiguration testConfiguration,
RoleConfiguration roleConfiguration,
Metrics metrics,
string testName,
CancellationToken cancellationToken)
{
if (role == RoleConfiguration.Publisher)
{
var publisherConfiguration = new PublisherConfiguration();
var publisher = new Publisher(publisherConfiguration, testConfiguration, metrics, testName);
await publisher.Start(cancellationToken);
}
if (role == RoleConfiguration.BufferedPublisher)
{
var publisherConfiguration = new BufferedPublisherConfiguration();
var publisher = new BufferedPublisher(testConfiguration, publisherConfiguration, metrics, testName);
await publisher.Start(cancellationToken);
}
if (role == RoleConfiguration.Processor)
{
var partitionCount = _getPartitionCount(testConfiguration.EventHubsConnectionString, testConfiguration.EventHub);
await partitionCount.ConfigureAwait(false);
var processConfiguration = new ProcessorConfiguration();
var processor = new Processor(testConfiguration, processConfiguration, metrics, partitionCount.Result, testName);
await processor.Start(cancellationToken);
}
if (role == RoleConfiguration.BurstBufferedPublisher)
{
var publisherConfiguration = new BufferedPublisherConfiguration();
publisherConfiguration.ProducerPublishingDelay = TimeSpan.FromMinutes(25);
var publisher = new BufferedPublisher(testConfiguration, publisherConfiguration, metrics, testName);
await publisher.Start(cancellationToken);
}
//return Task.CompletedTask;
await Task.Delay(TimeSpan.FromSeconds(1));
}
public void WillGenerateHTMLReportWithSummaryFilesCopied()
{
var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
var mockTool = new Mock <ICoverageParserTool>();
Directory.CreateDirectory(tempDir);
mockTool.Setup(x => x.GenerateHTMLReport());
var config = new PublisherConfiguration()
{
CoverageFiles = new List <string>()
{
"SampleCoverage/Clover.xml", "SampleCoverage/Cobertura.xml", "SampleCoverage/Jacoco.xml"
},
ReportDirectory = tempDir
};
var parser = new TestParser(config, _mockTelemetry.Object);
parser.GenerateReport(mockTool.Object);
var tempDirSummary = Directory.EnumerateDirectories(tempDir, "Summary_*").ToList()[0];
foreach (var summaryFile in config.CoverageFiles)
{
var fileName = Path.GetFileName(summaryFile);
Assert.IsTrue(File.Exists(Path.Combine(tempDirSummary, fileName)));
}
//cleanup
Directory.Delete(tempDir, true);
Assert.IsTrue(_logger.Log.Contains("debug: Parser.GenerateHTMLReport: Creating summary file directory:"));
Assert.IsTrue(_logger.Log.Contains(@"
debug: Parser.GenerateHTMLReport: Copying summary file SampleCoverage/Clover.xml
debug: Parser.GenerateHTMLReport: Copying summary file SampleCoverage/Cobertura.xml
debug: Parser.GenerateHTMLReport: Copying summary file SampleCoverage/Jacoco.xml
".Trim()));
}
public void WillLogIfReportDirectoryDoesntExist()
{
var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
var mockTool = new Mock <ICoverageParserTool>();
mockTool.Setup(x => x.GenerateHTMLReport());
var config = new PublisherConfiguration()
{
CoverageFiles = new List <string>()
{
"SampleCoverage/Clover.xml", "SampleCoverage/Cobertura.xml", "SampleCoverage/Jacoco.xml"
},
ReportDirectory = tempDir
};
var parser = new TestParser(config, _mockTelemetry.Object);
parser.GenerateReport(mockTool.Object);
Assert.IsTrue(_logger.Log.Contains("debug: Parser.GenerateHTMLReport: Directory".Trim()));
Assert.IsTrue(_logger.Log.Contains("doesn't exist, skipping copying of coverage input files.".Trim()));
}
public Task PublishAsync <T>(T message = default(T), Guid globalMessageId = new Guid(), Action <IPublishConfigurationBuilder> configuration = null)
{
var config = _configEval.GetConfiguration <T>(configuration);
var exchangeCfg = config.Exchange.AssumeInitialized
? null
: new ExchangeDeclaration
{
AutoDelete = config.Exchange.AutoDelete,
Durable = config.Exchange.Durable,
ExchangeType = config.Exchange.ExchangeType,
Name = config.Exchange.ExchangeName,
Arguments = config.Exchange.Arguments
};
var publisherCfg = new PublisherConfiguration
{
Exchange = exchangeCfg,
ExchangeName = config.Exchange.ExchangeName,
RoutingKey = config.RoutingKey,
BasicProperties = new BasicProperties(),
Mandatory = config.BasicReturn != null,
ReturnCallback = config.BasicReturn
};
config.PropertyModifier?.Invoke(publisherCfg.BasicProperties);
Action <IPipeContext> ctxAction = context =>
{
context.Properties.TryAdd(PipeKey.PublisherConfiguration, publisherCfg);
context.Properties.TryAdd(PipeKey.BasicPublishConfiguration, publisherCfg);
context.Properties.TryAdd(PipeKey.ExchangeDeclaration, exchangeCfg);
context.Properties.TryAdd(PipeKey.ReturnCallback, publisherCfg.ReturnCallback);
};
return(_client.PublishAsync(message: message, context: ctxAction));
}
public async Task ParseAndPublishCoverage(PublisherConfiguration config, CancellationToken token, Parser parser)
{
if (_publisher != null)
{
try
{
_telemetry.AddOrUpdate("PublisherConfig", () =>
{
return("{" +
$"\"InputFilesCount\": {config.CoverageFiles.Count}," +
$"\"SourceDirectoryProvided\": {config.SourceDirectory != ""}," +
$"\"GenerateHtmlReport\": {config.GenerateHTMLReport}," +
$"\"GenerateHtmlReport\": {config.TimeoutInSeconds}" +
"}");
});
var supportsFileCoverageJson = _publisher.IsFileCoverageJsonSupported();
if (supportsFileCoverageJson)
{
TraceLogger.Debug("Publishing file json coverage is supported.");
var fileCoverage = parser.GetFileCoverageInfos();
_telemetry.AddOrUpdate("UniqueFilesCovered", fileCoverage.Count);
if (fileCoverage.Count == 0)
{
TraceLogger.Warning(Resources.NoCoverageFilesGenerated);
}
else
{
using (new SimpleTimer("CoverageProcesser", "PublishFileCoverage", _telemetry))
{
await _publisher.PublishFileCoverage(fileCoverage, token);
}
}
}
else
{
TraceLogger.Debug("Publishing file json coverage is not supported.");
var summary = parser.GetCoverageSummary();
if (summary == null || summary.CodeCoverageData.CoverageStats.Count == 0)
{
TraceLogger.Warning(Resources.NoSummaryStatisticsGenerated);
}
else
{
using (new SimpleTimer("CoverageProcesser", "PublishCoverageSummary", _telemetry))
{
await _publisher.PublishCoverageSummary(summary, token);
}
}
}
if (config.GenerateHTMLReport)
{
if (!Directory.Exists(config.ReportDirectory))
{
TraceLogger.Warning(Resources.NoReportDirectoryGenerated);
}
else
{
using (new SimpleTimer("CoverageProcesser", "PublishHTMLReport", _telemetry))
{
await _publisher.PublishHTMLReport(config.ReportDirectory, token);
}
}
}
}
// Only catastrophic failures should trickle down to these catch blocks
catch (ParsingException ex)
{
_telemetry.AddFailure(ex);
TraceLogger.Error($"{ex.Message} {ex.InnerException}");
}
catch (Exception ex)
{
_telemetry.AddFailure(ex);
TraceLogger.Error(string.Format(Resources.ErrorOccuredWhilePublishing, ex));
}
}
}
/// <summary>
/// Create an entire stack.
/// </summary>
/// <param name="readerId"></param>
/// <param name="config"></param>
/// <returns></returns>
public static IStack CreateStack(string readerId, CollectorConfiguration config)
{
var stack = ComponentRegistration.CreateInstance <IStack>(config.StackType);
foreach (var readerConfig in config.Readers)
{
if (readerConfig.Id == readerId)
{
var newReaderId = Guid.NewGuid().ToString();
List <IPublisher> publishers = new List <IPublisher>();
List <ITransformer> transformers = new List <ITransformer>();
foreach (var transformerConfig in config.Transformers)
{
if (transformerConfig.ReaderId == readerId)
{
var newTransformerId = Guid.NewGuid().ToString();
foreach (var publisherConfig in config.Publishers)
{
if (publisherConfig.TransformerId == transformerConfig.Id)
{
foreach (var endpoint in config.EndPoints)
{
if (endpoint.Id == publisherConfig.EndpointId)
{
var newEndpoint = new EndPointConfiguration()
{
Id = Guid.NewGuid().ToString(),
Password = endpoint.Password,
User = endpoint.User
};
foreach (var key in endpoint.Properties.Keys)
{
newEndpoint.Properties.Add(key, endpoint.Properties[key]);
}
var newPublisherConfig = new PublisherConfiguration()
{
Id = Guid.NewGuid().ToString(),
EndpointId = newEndpoint.Id,
TransformerId = newTransformerId,
Type = publisherConfig.Type
};
var publisher = CreatePublisher(newPublisherConfig, endpoint);
publishers.Add(publisher);
}
}
}
}
var newTransformerConfig = new TransformerConfiguration()
{
Id = newTransformerId,
Type = transformerConfig.Type,
ReaderId = newReaderId,
};
foreach (var mapper in transformerConfig.Mappers)
{
var newMapperConfig = new MapperConfiguration()
{
Id = mapper.Id,
DataType = mapper.DataType,
TransformerId = newTransformerId,
Type = mapper.Type,
SourceTargetMappings = mapper.SourceTargetMappings
};
foreach (var converter in mapper.PipedConverters)
{
var newConverter = CopyConfig(converter);
newMapperConfig.PipedConverters.Add(converter);
}
foreach (var converter in mapper.Converters)
{
var newConverter = CopyConfig(converter);
newMapperConfig.Converters.Add(converter);
}
newTransformerConfig.Mappers.Add(newMapperConfig);
}
var transformer = CreateTransformer(newTransformerConfig, stack);
transformers.Add(transformer);
}
}
foreach (var endpoint in config.EndPoints)
{
if (readerConfig.EndpointId.Equals(endpoint.Id))
{
var newEndpoint = new EndPointConfiguration()
{
Id = Guid.NewGuid().ToString(),
Password = endpoint.Password,
User = endpoint.User
};
foreach (var key in endpoint.Properties.Keys)
{
newEndpoint.Properties.Add(key, endpoint.Properties[key]);
}
var reader = CreateReader(readerConfig.Type, newReaderId, newEndpoint, stack);
stack.Configure(reader, transformers, publishers);
break;
}
}
break;
}
}
return(stack);
}
public TestParser(PublisherConfiguration config, ITelemetryDataCollector telemetryDataCollector, ICoverageParserTool tool) : base(config, telemetryDataCollector)
{
_tool = tool;
}
public TestParser(PublisherConfiguration config, ITelemetryDataCollector telemetryDataCollector) : base(config, telemetryDataCollector)
{
}
public IQueuePublisher GetPublisher(PublisherConfiguration configuration)
{
string queueName = configuration.Queue.Name;
return(new QueuePublisher(queueName, PublishMessageAsync));
}
protected virtual ICoverageParserTool GetCoverageParserTool(PublisherConfiguration config)
{
// Currently there's only one parser tool, so simply return that instead of having a factory
return(new ReportGeneratorTool(config));
}
/// <summary>
/// Create a new session summary as the live collection session for the current process
/// </summary>
/// <remarks>This constructor figures out all of the summary information when invoked, which can take a moment.</remarks>
internal SessionSummary(AgentConfiguration configuration)
{
m_IsLive = true;
m_Packet = new SessionSummaryPacket();
m_SessionStatus = SessionStatus.Running;
m_PrivacyEnabled = configuration.Publisher.EnableAnonymousMode;
try
{
m_Packet.ID = Guid.NewGuid();
m_Packet.Caption = null;
//this stuff all tends to succeed
if (m_PrivacyEnabled)
{
m_Packet.UserName = string.Empty;
m_Packet.UserDomainName = string.Empty;
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
m_Packet.UserName = System.Environment.GetEnvironmentVariable("USERNAME") ?? string.Empty;
m_Packet.UserDomainName = System.Environment.GetEnvironmentVariable("USERDOMAIN") ?? string.Empty;
}
else
{
m_Packet.UserName = System.Environment.GetEnvironmentVariable("USER") ?? string.Empty;
m_Packet.UserDomainName = System.Environment.GetEnvironmentVariable("HOSTNAME") ?? string.Empty;
}
m_Packet.TimeZoneCaption = TimeZoneInfo.Local.StandardName;
m_Packet.EndDateTime = StartDateTime; //we want to ALWAYS have an end time, and since we just created our start time we need to move that over to end time
//this stuff, on the other hand, doesn't always succeed
//Lets see if the user has already picked some things for us...
PublisherConfiguration publisherConfig = configuration.Publisher;
string productName = null, applicationName = null, applicationDescription = null;
Version applicationVersion = null;
//what kind of process are we?
if (publisherConfig.ApplicationType != ApplicationType.Unknown)
{
// They specified an application type, so just use that.
m_AgentAppType = publisherConfig.ApplicationType; // Start with the type they specified.
}
m_Packet.ApplicationType = m_AgentAppType; // Finally, set the application type from our determined type.
if (m_AgentAppType != ApplicationType.AspNet)
{
//we want to find our entry assembly and get default product/app info from it.
GetApplicationNameSafe(out productName, out applicationName, out applicationVersion, out applicationDescription);
}
//OK, now apply configuration overrides or what we discovered...
m_Packet.ProductName = string.IsNullOrEmpty(publisherConfig.ProductName) ? productName : publisherConfig.ProductName;
m_Packet.ApplicationName = string.IsNullOrEmpty(publisherConfig.ApplicationName) ? applicationName : publisherConfig.ApplicationName;
m_Packet.ApplicationVersion = publisherConfig.ApplicationVersion ?? applicationVersion;
m_Packet.ApplicationDescription = string.IsNullOrEmpty(publisherConfig.ApplicationDescription) ? applicationDescription : publisherConfig.ApplicationDescription;
m_Packet.EnvironmentName = publisherConfig.EnvironmentName;
m_Packet.PromotionLevelName = publisherConfig.PromotionLevelName;
//Finally, no nulls allowed! Fix any...
m_Packet.ProductName = string.IsNullOrEmpty(m_Packet.ProductName) ? "Unknown" : m_Packet.ProductName;
m_Packet.ApplicationName = string.IsNullOrEmpty(m_Packet.ApplicationName) ? "Unknown" : m_Packet.ApplicationName;
m_Packet.ApplicationVersion = m_Packet.ApplicationVersion ?? new Version(0, 0);
m_Packet.ApplicationDescription = m_Packet.ApplicationDescription ?? string.Empty;
m_Packet.EnvironmentName = m_Packet.EnvironmentName ?? string.Empty;
m_Packet.PromotionLevelName = m_Packet.PromotionLevelName ?? string.Empty;
m_Packet.ComputerId = GetComputerIdSafe(m_Packet.ProductName, configuration);
m_Packet.AgentVersion = GetAgentVersionSafe();
}
catch (Exception ex)
{
//we really don't want an init error to fail us, not here!
GC.KeepAlive(ex);
}
if (m_PrivacyEnabled == false)
{
try
{
IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
m_Packet.HostName = ipGlobalProperties.HostName;
m_Packet.DnsDomainName = ipGlobalProperties.DomainName ?? string.Empty;
}
catch
{
//fallback to environment names
try
{
m_Packet.HostName = System.Environment.MachineName;
}
catch (Exception ex)
{
//we really don't want an init error to fail us, not here!
GC.KeepAlive(ex);
m_Packet.HostName = "unknown";
}
m_Packet.DnsDomainName = string.Empty;
}
}
else
{
// Privacy mode. Don't store "personally-identifying information".
m_Packet.HostName = "anonymous";
m_Packet.DnsDomainName = string.Empty;
}
var os = System.Environment.OSVersion;
m_Packet.OSPlatformCode = (int)os.Platform; //we copied this enum for our value.
m_Packet.OSVersion = os.Version;
m_Packet.OSServicePack = os.ServicePack;
try
{
m_Packet.OSArchitecture = RuntimeInformation.OSArchitecture.ToProcessorArchitecture();
m_Packet.RuntimeArchitecture = RuntimeInformation.ProcessArchitecture.ToProcessorArchitecture();
m_Packet.OSCultureName = CultureInfo.CurrentUICulture.ToString();
m_Packet.CurrentCultureName = CultureInfo.CurrentCulture.ToString();
m_Packet.CurrentUICultureName = CultureInfo.CurrentUICulture.ToString();
m_Packet.OSBootMode = OSBootMode.Normal;
m_Packet.Processors = System.Environment.ProcessorCount;
m_Packet.ProcessorCores = m_Packet.Processors; //BUG
try
{
var frameworkDescription = RuntimeInformation.FrameworkDescription;
//hopefully this has a version number in it...
//Thanks to SO.. https://stackoverflow.com/questions/6618868/regular-expression-for-version-numbers
var versionMatch = Regex.Match(frameworkDescription, @"\d+(?:\.\d+)+");
if (versionMatch.Success)
{
if (Version.TryParse(versionMatch.Value, out var version))
{
m_Packet.RuntimeVersion = version;
}
else
{
m_Packet.RuntimeVersion = new Version(0, 0);
}
}
}
catch (Exception ex)
{
GC.KeepAlive(ex);
m_Packet.RuntimeVersion = new Version(0, 0);
}
m_Packet.MemoryMB = 0; // BUG
m_Packet.UserInteractive = System.Environment.UserInteractive;
//find the active screen resolution
if (m_AgentAppType == ApplicationType.Windows)
{
//We don't know if we can reliably get these on .NET Core.
m_Packet.TerminalServer = false;
m_Packet.ColorDepth = 0;
m_Packet.ScreenHeight = 0;
m_Packet.ScreenWidth = 0;
}
if (m_PrivacyEnabled)
{
m_Packet.CommandLine = string.Empty;
}
else
{
//.NET Core doesn't expose the command line because of concerns over how it is handled cross-platform.
var commandArgs = System.Environment.GetCommandLineArgs();
m_Packet.CommandLine = string.Join(" ", commandArgs); //the first arg is the executable name
}
}
catch (Exception ex)
{
//we really don't want an init error to fail us, not here!
GC.KeepAlive(ex);
}
//now do user defined properties
try
{
foreach (KeyValuePair <string, string> keyValuePair in configuration.Properties)
{
m_Packet.Properties.Add(keyValuePair.Key, keyValuePair.Value);
}
}
catch (Exception ex)
{
//we aren't expecting any errors, but best be safe.
GC.KeepAlive(ex);
}
m_Packet.Caption = m_Packet.ApplicationName;
}
