private void ConfigureMaxEntries(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
{
string maxEntriesstring = collectorNameValueConfigurationManager[EventLogConstants.SettingMaxEntries];
if (maxEntriesstring != null)
{
try
{
this.maxEntries = int.Parse(maxEntriesstring, CultureInfo.InvariantCulture);
// A negative or 0 value means no maximum
if (this.maxEntries <= 0)
{
this.maxEntries = int.MaxValue;
}
}
catch (FormatException)
{
this.maxEntries = EventLogConstants.DefaultMaxEntries;
}
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(
"EventLogDataCollector configuration: " + EventLogConstants.SettingMaxEntries + "="
+ this.maxEntries);
}
}
else
{
this.maxEntries = EventLogConstants.DefaultMaxEntries;
}
}
private void ConfigureEntryTypes(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
{
this.entryTypes = new HashSet <EventLogEntryType>();
string entryTypesStr = collectorNameValueConfigurationManager[EventLogConstants.SettingEntryTypes];
if (entryTypesStr != null)
{
foreach (string entryTypestring in ParseCommaSeparatedList(entryTypesStr))
{
this.entryTypes.Add(
(EventLogEntryType)Enum.Parse(typeof(EventLogEntryType), entryTypestring, true));
}
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(
"EventLogDataCollector configuration: " + EventLogConstants.SettingEntryTypes + "="
+ this.entryTypes);
}
}
else
{
this.entryTypes.Add(EventLogEntryType.Error);
this.entryTypes.Add(EventLogEntryType.Warning);
this.entryTypes.Add(EventLogEntryType.FailureAudit);
}
}
/// <summary>
/// Initializes the data collector
/// </summary>
/// <param name="configurationElement">
/// The XML element containing configuration information for the data collector. Currently,
/// this data collector does not have any configuration, so we ignore this parameter.
/// </param>
/// <param name="events">
/// Object containing the execution events the data collector registers for
/// </param>
/// <param name="dataSink">The sink used by the data collector to send its data</param>
/// <param name="logger">
/// Used by the data collector to send warnings, errors, or other messages
/// </param>
/// <param name="dataCollectionEnvironmentContext">Provides contextual information about the agent environment</param>
public override void Initialize(
XmlElement configurationElement,
DataCollectionEvents events,
DataCollectionSink dataSink,
DataCollectionLogger logger,
DataCollectionEnvironmentContext dataCollectionEnvironmentContext)
{
ValidateArg.NotNull(events, nameof(events));
ValidateArg.NotNull(dataSink, nameof(dataSink));
ValidateArg.NotNull(logger, nameof(logger));
this.events = events;
this.dataSink = dataSink;
this.logger = logger;
this.dataCollectorContext = dataCollectionEnvironmentContext.SessionDataCollectionContext;
// Load the configuration
CollectorNameValueConfigurationManager nameValueSettings =
new CollectorNameValueConfigurationManager(configurationElement);
// Apply the configuration
this.ConfigureEventSources(nameValueSettings);
this.ConfigureEntryTypes(nameValueSettings);
this.ConfigureMaxEntries(nameValueSettings);
this.ConfigureEventLogNames(nameValueSettings);
// Register for events
events.SessionStart += this.sessionStartEventHandler;
events.SessionEnd += this.sessionEndEventHandler;
events.TestCaseStart += this.testCaseStartEventHandler;
events.TestCaseEnd += this.testCaseEndEventHandler;
}
private void ConfigureEventLogNames(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
{
this.eventLogNames = new HashSet <string>();
string eventLogs = collectorNameValueConfigurationManager[EventLogConstants.SettingEventLogs];
if (eventLogs != null)
{
this.eventLogNames = ParseCommaSeparatedList(eventLogs);
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(
"EventLogDataCollector configuration: " + EventLogConstants.SettingEventLogs + "=" + eventLogs);
}
}
else
{
// Default to collecting these standard logs
this.eventLogNames.Add("System");
this.eventLogNames.Add("Security");
this.eventLogNames.Add("Application");
}
foreach (string eventLogName in this.eventLogNames)
{
try
{
// Create an EventLog object and add it to the eventLogContext if one does not already exist
if (!this.eventLogContainerMap.ContainsKey(eventLogName))
{
IEventLogContainer eventLogContainer = new EventLogContainer(
eventLogName,
this.eventSources,
this.entryTypes,
int.MaxValue,
this.logger,
this.dataCollectorContext);
this.eventLogContainerMap.Add(eventLogName, eventLogContainer);
}
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(string.Format(
CultureInfo.InvariantCulture,
"EventLogDataCollector: Created EventSource '{0}'",
eventLogName));
}
}
catch (Exception ex)
{
this.logger.LogError(
null,
new EventLogCollectorException(string.Format(CultureInfo.InvariantCulture, Resource.ReadError, eventLogName, Environment.MachineName), ex));
}
}
}
private void ConfigureEventSources(CollectorNameValueConfigurationManager collectorNameValueConfigurationManager)
{
string eventSourcesStr = collectorNameValueConfigurationManager[EventLogConstants.SettingEventSources];
if (!string.IsNullOrEmpty(eventSourcesStr))
{
this.eventSources = ParseCommaSeparatedList(eventSourcesStr);
if (EqtTrace.IsVerboseEnabled)
{
EqtTrace.Verbose(
"EventLogDataCollector configuration: " + EventLogConstants.SettingEventSources + "="
+ this.eventSources);
}
}
}