protected override void OnEventSourceCreated(EventSource eventSource)
{
// There is a possible race where we can get notified of the creation of our own internal logger during
// construction of the log manager. The LogManager constructor helps handle this by explicitly calling
// this function once it is safe to do so.
if (eventSource is InternalLogger && InternalLogger.Write == null)
{
return;
}
lock (this.eventSourceInfosLock)
{
if (!this.eventSourceInfos.ContainsKey(eventSource))
{
var updatedData = new EventSourceInfo(eventSource);
this.eventSourceInfos[eventSource] = updatedData;
InternalLogger.Write.NewEventSource(eventSource.Name, eventSource.Guid);
}
else
{
return; // we should have already done the work for this source.
}
}
lock (this.loggersLock)
{
if (this.logConfigurations != null)
{
foreach (var kvp in this.logConfigurations)
{
LogConfiguration config = kvp.Value;
// We need to update our loggers any time a config shows up where they had a dependency
// that probably wasn't resolved. This will be the case either when it was a named source
// or it was a GUID source on a type that can't directly subscribe to GUIDs (i.e. not an ETW
// trace session)
IEventLogger logger = null;
switch (config.FileType)
{
case LoggerType.Console:
logger = this.consoleLogger;
break;
case LoggerType.Network:
logger = this.GetNamedNetworkLogger(kvp.Key);
break;
default:
logger = this.GetNamedFileLogger(kvp.Key).Logger;
break;
}
LogSourceLevels levels;
if (config.NamedSources.TryGetValue(eventSource.Name, out levels) ||
(!config.HasFeature(LogConfiguration.Features.GuidSubscription) &&
config.GuidSources.TryGetValue(eventSource.Guid, out levels)))
{
ApplyConfigForEventSource(config, logger, eventSource, levels);
}
}
}
}
}
protected override void OnEventSourceCreated(EventSource eventSource)
{
// There is a possible race where we can get notified of the creation of our own internal logger during
// construction of the log manager. The LogManager constructor helps handle this by explicitly calling
// this function once it is safe to do so.
if (eventSource is InternalLogger && InternalLogger.Write == null)
{
return;
}
lock (this.eventSourceInfosLock)
{
if (!this.eventSourceInfos.ContainsKey(eventSource))
{
var updatedData = new EventSourceInfo(eventSource);
this.eventSourceInfos[eventSource] = updatedData;
InternalLogger.Write.NewEventSource(eventSource.Name, eventSource.Guid);
}
else
{
return; // we should have already done the work for this source.
}
}
lock (this.loggersLock)
{
foreach (var log in Configuration.Logs)
{
log.UpdateForEventSource(eventSource);
}
}
}
/// <summary>
/// Parses the <see cref="EventSource"/> class and returns the <see cref="EventSourceInfo"/> object
/// </summary>
/// <param name="eventSource">Event source to be parsed</param>
/// <param name="friendlyName">Friendly name of the event source</param>
/// <returns>event source info</returns>
public static EventSourceInfo Parse(EventSource eventSource, string friendlyName)
{
if (string.IsNullOrEmpty(friendlyName))
{
friendlyName = eventSource.Name;
}
var info = new EventSourceInfo {
FriendlyName = friendlyName,
};
foreach (var method in eventSource.GetType().GetMethods())
{
var eventAttribute = method.GetCustomAttribute <EventAttribute>();
if (eventAttribute == null)
{
continue;
}
var id = eventAttribute.EventId;
var name = method.Name;
var parameters = method.GetParameters().Select(p => p.Name).ToArray();
info.events.Add(id, Tuple.Create(name, parameters));
}
return(info);
}
/// <summary>
/// Adds the given event source to listening
/// </summary>
/// <param name="eventSourceName">Full name of the event source to be listened</param>
/// <param name="level">Event level</param>
/// <param name="shortName">Short and friendly name of the event source</param>
/// <returns>True if the event source is listened successfully, false if otherwise</returns>
public static bool AddEventSource(string eventSourceName, EventLevel level = EventLevel.Verbose, string shortName = null)
{
if (instance == null)
{
throw new InvalidOperationException();
}
Contract.EndContractBlock();
var eventSource = EventSource.GetSources().FirstOrDefault(s => s.Name == eventSourceName);
if (eventSource != null)
{
instance.listenedEventSources.Add(eventSource.Name, EventSourceInfo.Parse(eventSource, shortName));
instance.EnableEvents(eventSource, level);
Trace($"Event source {eventSourceName} enabled.");
return(true);
}
else
{
return(false);
}
}
protected override void OnEventSourceCreated(EventSource eventSource)
{
// There is a possible race where we can get notified of the creation of our own internal logger during
// construction of the log manager. The LogManager constructor helps handle this by explicitly calling
// this function once it is safe to do so.
if (eventSource is InternalLogger && InternalLogger.Write == null)
{
return;
}
lock (this.eventSourceInfosLock)
{
if (!this.eventSourceInfos.ContainsKey(eventSource))
{
var updatedData = new EventSourceInfo(eventSource);
this.eventSourceInfos[eventSource] = updatedData;
InternalLogger.Write.NewEventSource(eventSource.Name, eventSource.Guid);
}
else
{
return; // we should have already done the work for this source.
}
}
lock (this.loggersLock)
{
if (this.logConfigurations != null)
{
foreach (var kvp in this.logConfigurations)
{
LogConfiguration config = kvp.Value;
// We need to update our loggers any time a config shows up where they had a dependency
// that probably wasn't resolved. This will be the case either when it was a named source
// or it was a GUID source on a type that can't directly subscribe to GUIDs (i.e. not an ETW
// trace session)
IEventLogger logger = null;
switch (config.FileType)
{
case LoggerType.Console:
logger = this.consoleLogger;
break;
case LoggerType.Network:
logger = this.GetNamedNetworkLogger(kvp.Key);
break;
default:
logger = this.GetNamedFileLogger(kvp.Key).Logger;
break;
}
LogSourceLevels levels;
if (config.NamedSources.TryGetValue(eventSource.Name, out levels) ||
(!config.HasFeature(LogConfiguration.Features.GuidSubscription) &&
config.GuidSources.TryGetValue(eventSource.Guid, out levels)))
{
ApplyConfigForEventSource(config, logger, eventSource, levels);
}
}
}
}
}
