public void Ignore(IEventTag eventTag)
{
if (eventTag != null)
{
_ignoredTags.Add(eventTag);
}
}
public void ShouldReturnADisposableSubscription()
{
var tags = new IEventTag[] { new EventTag("some-event") };
var bc = new Broadcaster(channel, tags);
Assert.IsInstanceOf <IDisposable> (channel.Subscribe(bc));
}
/// <summary>
/// This assert fires in both debug and release configurations
/// </summary>
/// <param name="tag">A unique tag for this assert</param>
/// <param name="category">The category to use for this assert. This can cause your assert to be filtered out from the logging stream.</param>
/// <param name="condition">When this condition is FALSE, the assert will be logged</param>
/// <param name="args">The arguments to be logged. These should at least contain the items in your condition.</param>
public static void ShipAssert(IEventTag tag, UInt32 category, bool condition, params object[] args)
{
if (!condition)
{
RecordEvent(tag, category, AssertSeverity, args);
}
}
public void DontIgnore(IEventTag eventTag)
{
if (eventTag != null)
{
_ignoredTags.Remove(eventTag);
}
}
public bool IsIgnoring(IEventTag eventTag)
{
var isIgnored = false;
if (eventTag == null || _ignoredTags.Contains(eventTag))
{
isIgnored = true;
}
return(isIgnored);
}
public IBroadcaster GetBroadcasterFor(IEventTag eventTag)
{
IBroadcaster broadcaster = EmptyBroadcaster.Instance;
if (eventTag != EmptyEventTag.Instance)
{
IBroadcaster result;
Registry.TryGetValue(eventTag, out result);
broadcaster = result is Broadcaster ? result : broadcaster;
}
return(broadcaster);
}
public bool IsWatching(IEventTag eventTag)
{
var isWatching = false;
foreach (SubscriptionInfo info in _subscriptionsInfo.Values)
{
isWatching = info.EventTags.Contains(eventTag);
if (isWatching)
{
break;
}
}
return(isWatching);
}
public IEventTag GetEventTag(string tagName)
{
IEventTag eventTag = EmptyEventTag.Instance;
foreach (IEventTag key in Registry.Keys)
{
if (key.Name.Contains(tagName))
{
eventTag = key;
break;
}
}
return(eventTag);
}
public ISignal CreateSignal(IEventTag eventTag, IMessage message)
{
ISignal signal = EmptySignal.Instance;
if (eventTag != null && message != null)
{
signal = new Signal(
signaller: this,
eventTag: eventTag ?? EmptyEventTag.Instance,
message: message ?? EmptyMessage.Instance
);
}
return(signal);
}
public static void EndPerformanceTimer(IEventTag eventTag, UInt32 category, UInt32 timerId)
{
var now = Environment.TickCount;
if (!_timers.Contains(timerId))
{
#if DEBUG
throw new Exception("Timer ID not found");
#else
return;
#endif
}
var then = (int)_timers[timerId];
var interval = now - then;
RecordEvent(eventTag, category, Severity.Performance, interval);
}
public void Watch(IBroadcaster broadcaster, IEventTag eventTag)
{
if (broadcaster != null && eventTag != null)
{
var tags = new IEventTag[] { eventTag };
IDisposable subscription = _MakeSubscription(broadcaster, tags);
if (_subscriptionsInfo.ContainsKey(broadcaster))
{
_RemoveSubscriptionFor(broadcaster);
}
if (subscription != null)
{
_AddSubscriptionInfo(
broadcaster: broadcaster,
subscription: subscription,
eventTags: tags
);
}
}
}
public void Ignore(IEventTag eventTag)
{
}
public bool IsWatching(IEventTag eventTag)
{
return(false);
}
public static void Verbose(IEventTag eventTag, UInt32 category, params object[] args)
{
RecordEvent(eventTag, category, Severity.Verbose, args);
}
public void Watch(IBroadcaster broadcaster, IEventTag eventTag)
{
}
public static void RecordEvent(IEventTag eventTag, UInt32 category, Severity severity, params object[] args)
{
if (args.Length > 255)
{
throw new Exception("Number of arguments to log is > 255");
}
if ((eventTag.Tag & ListenerReservedEventTags) == ListenerReservedEventTags)
{
throw new Exception("Listener reserved event tag - tags in this range are for internal use by listeners");
}
// Short-circuit if there are no listeners. ("If a log entry falls in the forest and no listener is there to hear it...")
if (_listeners.Count == 0)
{
return;
}
// Ignore the event if its category is masked off
if ((category & _categories) == 0)
{
return;
}
// Ignore the event if it falls below the min severity
if (severity < _minSev)
{
return;
}
// Looks like we've got a keeper - log it
lock (_sync)
{
int blocksize = 0;
var typeCodes = new byte[args.Length + 1];
typeCodes[0] = (byte)args.Length;
for (var i = 0; i < args.Length; ++i)
{
blocksize += LengthOf(args[i]);
typeCodes[i + 1] = (byte)TypeCodeOf(args[i]);
}
blocksize += (
sizeof(UInt32) + // record size
sizeof(UInt32) + // eventTag
sizeof(long) + // timestamp
sizeof(UInt32) + // category
sizeof(byte) + // severity
typeCodes.Length * sizeof(byte) // argument count and type codes
);
byte[] buffer = new byte[blocksize];
int offset = 0;
Marshall(buffer, ref offset, (UInt32)blocksize);
Marshall(buffer, ref offset, eventTag.Tag);
Marshall(buffer, ref offset, DateTime.UtcNow);
Marshall(buffer, ref offset, category);
Marshall(buffer, ref offset, (byte)severity);
Marshall(buffer, ref offset, typeCodes);
foreach (var arg in args)
{
Marshall(buffer, ref offset, arg);
}
foreach (var listener in _listeners)
{
((ITraceListener)listener).RecordEvent(buffer);
}
}
}
public static void EndPerformanceTimer(IEventTag eventTag, UInt32 timerId)
{
EndPerformanceTimer(eventTag, DefaultCategories, timerId);
}
public static void Critical(IEventTag eventTag, UInt32 category, params object[] args)
{
RecordEvent(eventTag, category, Severity.Critical, args);
}
public static void Error(IEventTag eventTag, UInt32 category, params object[] args)
{
RecordEvent(eventTag, category, Severity.Error, args);
}
public ISignal CreateSignal(IEventTag eventTag, IMessage message)
{
return(EmptySignal.Instance);
}
public bool IsIgnoring(IEventTag tag)
{
return(false);
}
public void AddEvent(IEventTag eventTag)
{
}
public void AddEvent(IEventTag eventTag)
{
var entry = new EventEntry(eventTag, DefaultBroadcaster);
AddEventEntry(entry);
}
public bool HasEventTag(IEventTag eventTag)
{
return(Registry.ContainsKey(eventTag));
}
public bool HasEventTag(IEventTag eventTag)
{
return(false);
}
public void DontIgnore(IEventTag eventTag)
{
}
public IBroadcaster GetBroadcasterFor(IEventTag eventTag)
{
return(EmptyBroadcaster.Instance);
}
public static void Warning(IEventTag eventTag, UInt32 category, params object[] args)
{
RecordEvent(eventTag, category, Severity.Warning, args);
}
public EventEntry(IEventTag eventTag, IBroadcaster broadcaster)
{
_eventTag = eventTag;
_broadcaster = broadcaster;
}
public Signal(ISignaller signaller, IEventTag eventTag, IMessage message = default(IMessage))
{
_eventTag = eventTag ?? EmptyEventTag.Instance;
_message = message ?? EmptyMessage.Instance;
_signaller = signaller ?? EmptySignaller.Instance;
}
