internal static HealthMonitoringManager Manager()
{
if (s_initing)
{
return null;
}
if (!s_inited)
{
lock (s_lockObject)
{
if (s_inited)
{
return s_manager;
}
try
{
s_initing = true;
s_manager = new HealthMonitoringManager();
}
finally
{
s_initing = false;
s_inited = true;
}
}
}
return s_manager;
}
private static void RaiseSystemEventInternal(string message, object source, int eventCode, int eventDetailCode, Exception exception, string nameToAuthenticate)
{
if (HealthMonitoringManager.Enabled)
{
SystemEventTypeInfo info;
SystemEventType type;
int num;
int num2;
WebEventCodes.GetEventArrayIndexsFromEventCode(eventCode, out num, out num2);
GetSystemEventTypeInfo(eventCode, num, num2, out info, out type);
if (info != null)
{
ArrayList firingRuleInfos = HealthMonitoringManager.Manager()._sectionHelper.FindFiringRuleInfos(info._type, eventCode);
if (firingRuleInfos.Count == 0)
{
info._dummyEvent.IncrementPerfCounters();
info._dummyEvent.IncrementTotalCounters(num, num2);
}
else
{
RaiseInternal(NewEventFromSystemEventType(false, type, message, source, eventCode, eventDetailCode, exception, nameToAuthenticate), firingRuleInfos, num, num2);
}
}
}
}
internal static HealthMonitoringManager Manager()
{
if (s_initing)
{
return(null);
}
if (!s_inited)
{
lock (s_lockObject)
{
if (s_inited)
{
return(s_manager);
}
try
{
s_initing = true;
s_manager = new HealthMonitoringManager();
}
finally
{
s_initing = false;
s_inited = true;
}
}
}
return(s_manager);
}
internal static void StartHealthMonitoringHeartbeat()
{
HealthMonitoringManager manager = Manager();
if ((manager != null) && manager._enabled)
{
manager.StartHeartbeatTimer();
}
}
internal bool CheckAndUpdate(WebBaseEvent eventRaised)
{
DateTime now = DateTime.Now;
HealthMonitoringManager manager = HealthMonitoringManager.Manager();
int num = Interlocked.Increment(ref this._timesRaised);
if (manager == null)
{
return(false);
}
if (this._ruleInfo._customEvaluatorType != null)
{
IWebEventCustomEvaluator evaluator = (IWebEventCustomEvaluator)manager._sectionHelper._customEvaluatorInstances[this._ruleInfo._customEvaluatorType];
try
{
eventRaised.PreProcessEventInit();
if (!evaluator.CanFire(eventRaised, this))
{
return(false);
}
}
catch
{
return(false);
}
}
if (num < this._ruleInfo._minInstances)
{
return(false);
}
if (num > this._ruleInfo._maxLimit)
{
return(false);
}
if (this._ruleInfo._minInterval == TimeSpan.Zero)
{
this.UpdateLastFired(now, false);
return(true);
}
if ((now - this._lastFired) <= this._ruleInfo._minInterval)
{
return(false);
}
lock (this)
{
if ((now - this._lastFired) <= this._ruleInfo._minInterval)
{
return(false);
}
this.UpdateLastFired(now, true);
return(true);
}
}
internal static void RaiseInternal(WebBaseEvent eventRaised, ArrayList firingRuleInfos, int index0, int index1)
{
bool flag = false;
bool flag2 = false;
ProcessImpersonationContext context = null;
HttpContext current = HttpContext.Current;
object data = CallContext.GetData("_WEvtRIP");
if ((data == null) || !((bool)data))
{
eventRaised.IncrementPerfCounters();
eventRaised.IncrementTotalCounters(index0, index1);
if (firingRuleInfos == null)
{
firingRuleInfos = HealthMonitoringManager.Manager()._sectionHelper.FindFiringRuleInfos(eventRaised.GetType(), eventRaised.EventCode);
}
if (firingRuleInfos.Count != 0)
{
try
{
bool[] flagArray = null;
if (EtwTrace.IsTraceEnabled(5, 1) && (current != null))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_WEB_EVENT_RAISE_START, current.WorkerRequest, eventRaised.GetType().FullName, eventRaised.EventCode.ToString(CultureInfo.InstalledUICulture), eventRaised.EventDetailCode.ToString(CultureInfo.InstalledUICulture), null);
}
try
{
foreach (HealthMonitoringSectionHelper.FiringRuleInfo info in firingRuleInfos)
{
HealthMonitoringSectionHelper.RuleInfo info2 = info._ruleInfo;
if (info2._ruleFiringRecord.CheckAndUpdate(eventRaised) && (info2._referencedProvider != null))
{
if (!flag)
{
eventRaised.PreProcessEventInit();
flag = true;
}
if (info._indexOfFirstRuleInfoWithSameProvider != -1)
{
if (flagArray == null)
{
flagArray = new bool[firingRuleInfos.Count];
}
if (flagArray[info._indexOfFirstRuleInfoWithSameProvider])
{
continue;
}
flagArray[info._indexOfFirstRuleInfoWithSameProvider] = true;
}
if (EtwTrace.IsTraceEnabled(5, 1) && (current != null))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_WEB_EVENT_DELIVER_START, current.WorkerRequest, info2._ruleSettings.Provider, info2._ruleSettings.Name, info2._ruleSettings.EventName, null);
}
try
{
if (context == null)
{
context = new ProcessImpersonationContext();
}
if (!flag2)
{
CallContext.SetData("_WEvtRIP", true);
flag2 = true;
}
info2._referencedProvider.ProcessEvent(eventRaised);
}
catch (Exception exception)
{
try
{
info2._referencedProvider.LogException(exception);
}
catch
{
}
}
finally
{
if (EtwTrace.IsTraceEnabled(5, 1) && (current != null))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_WEB_EVENT_DELIVER_END, current.WorkerRequest);
}
}
}
}
}
finally
{
if (context != null)
{
context.Undo();
}
if (flag2)
{
CallContext.FreeNamedDataSlot("_WEvtRIP");
}
if (EtwTrace.IsTraceEnabled(5, 1) && (current != null))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_WEB_EVENT_RAISE_END, current.WorkerRequest);
}
}
}
catch
{
throw;
}
}
}
}
// If this method returns null, it means we failed during configuration.
internal static HealthMonitoringManager Manager() {
if (s_initing) {
Debug.Assert(!s_inited);
// If this is true, that means we are calling WebEventBase.Raise while
// we are initializing. That means Init() has caused a config exception.
return null;
}
if (s_inited) {
return s_manager;
}
lock (s_lockObject) {
if (s_inited) {
return s_manager;
}
try {
Debug.Assert(s_manager == null);
s_initing = true;
s_manager = new HealthMonitoringManager();;
}
finally {
s_initing = false;
s_inited = true;
}
}
return s_manager;
}
