protected override void Before_all_tests() { base.Before_all_tests(); logMessageHandler = LogMessageHandlerFactory.GetHandlerFor(LogMessage); }
/// <summary>Adds the given ILogMessageHandler to the indicated group</summary> public static void AddLogMessageHandlerToDistributionGroup(string groupName, ILogMessageHandler logMessageHandler) { GetLogMessageDistributionImpl().AddLogMessageHandlerToDistributionGroup(logMessageHandler, groupName); }
// methods used by global methods public void AddLogMessageHandlerToDistributionGroup(ILogMessageHandler logMessageHandler, string groupName) { lock (distMutex) { int dgid = InnerGetDistGroupID(groupName, true); if (!InnerIsDistGroupIDValid(dgid)) { Utils.Asserts.TakeBreakpointAfterFault("AddLogMessageHandler...::Given GroupName could not be created."); return; } PerDistGroupIDInfo dgInfo = distGroupIDInfoList [dgid]; if (logMessageHandler != null) { int dhInfoIdx = dgInfo.distHandlerInfoList.Count; dgInfo.Add(new DistHandlerInfo(logMessageHandler)); DistHandlerInfo distHandlerInfo = dgInfo.distHandlerInfoList [dhInfoIdx]; logMessageHandler.NotifyOnCompletedDelivery.AddItem(mesgDeliveryOccurredNotification); if (dgInfo.UpdateActiveLoggerConfig()) InnerUpdateLoggerDistGroupConfigForGroup(dgid); } } }
public DistHandlerInfo(ILogMessageHandler lmh) { LMH = lmh; }
//------------------------------------------------------------------- /// <summary>Adds the given ILogMessaeHandler to the default distribution group.</summary> public static void AddLogMessageHandlerToDefaultDistributionGroup(ILogMessageHandler logMessageHandler) { AddLogMessageHandlerToDistributionGroup(DefaultDistributionGroupName, logMessageHandler); }
/// <summary> /// Single targetLMH constructor. Derives name and LoggingConfig values from the given targetLMH. /// </summary> /// <param name="targetLMH">Gives the target LMH instance to which the queued messages will be delivered.</param> /// <param name="maxQueueSize">Defines te maximum number of messages that can be held internally before messages are lost.</param> public QueueLogMessageHandler(ILogMessageHandler targetLMH, int maxQueueSize) : this(targetLMH.Name, new[] { targetLMH }, maxQueueSize) { }
/// <summary> /// Multiple targetLMH constructor. Derives LoggingConfig values from the given targetLMH /// </summary> /// <param name="name">Gives the name of this LMH - different than the names of the target LMH instances</param> /// <param name="targetLMHArray">Gives the set of LMH instance that are to be given the dequeued LogMessages.</param> /// <param name="maxQueueSize">Defines te maximum number of messages that can be held internally before messages are lost.</param> public QueueLogMessageHandler(string name, ILogMessageHandler[] targetLMHArray, int maxQueueSize) : base(name, LogGate.None, false, false) { targetLMHArray = targetLMHArray ?? emptyLMHArray; LogGate logGate = LogGate.None; bool recordSourceStackFrame = false; bool supportsReferenceCountedRelease = true; foreach (ILogMessageHandler targetLMH in targetLMHArray) { logGate.MesgTypeMask |= targetLMH.LoggerConfig.LogGate.MesgTypeMask; recordSourceStackFrame |= targetLMH.LoggerConfig.RecordSourceStackFrame; supportsReferenceCountedRelease &= targetLMH.LoggerConfig.SupportsReferenceCountedRelease; } loggerConfig.LogGate = logGate; loggerConfig.RecordSourceStackFrame = recordSourceStackFrame; loggerConfig.SupportsReferenceCountedRelease = supportsReferenceCountedRelease; this.targetLMHArray = targetLMHArray; dist = Logging.GetLogMessageDistribution(); mesgDeliveryList = new List<LogMessage>(10); // define its initial capacity mesgQueue = new MessageQueue(maxQueueSize); mesgQueue.SetEffectiveSourceInfo(logger.LoggerSourceInfo); mesgQueue.EnableQueue(); mesgQueueMutex = mesgQueue.Mutex; // create and start the thread StartIfNeeded(); }
/// <summary> /// Single targetLMH constructor. Derives name and LoggingConfig values from the given targetLMH. /// </summary> /// <param name="targetLMH">Gives the target LMH instance to which the queued messages will be delivered.</param> /// <param name="maxQueueSize">Defines te maximum number of messages that can be held internally before messages are lost.</param> public QueueLogMessageHandler(ILogMessageHandler targetLMH, int maxQueueSize = DefaultMesgQueueSize) : this(targetLMH.Name + ".q", new[] { targetLMH }, maxQueueSize) { }
public LogController(ILogMessageHandler handler) { this.handler = handler; }
public ILogMessageHandler <T> SetNext(ILogMessageHandler <T> nextHandler) { Next = nextHandler; return(Next); }
/// <summary>Constructor</summary> /// <param name="logMesgHandler">Gives the LMH to which emitted messages will be passed.</param> public LogMesgHandlerLogger(ILogMessageHandler logMesgHandler) : base(logMesgHandler.Name, string.Empty, logMesgHandler.LoggerConfig.LogGate, false) { lmh = logMesgHandler; if (lmh == null) Utils.Asserts.TakeBreakpointAfterFault("LogMesgHandlerLogger: LMH == null"); sourceInfo = new LoggerSourceInfo(LoggerID_InternalLogger, Name); }
/// <summary>Creates a wrapper LMH that serves to Queue delivery of messages to the given targetLMH. Uses given maxQueueSize</summary> public static ILogMessageHandler CreateQueueLogMessageHandler(ILogMessageHandler targetLMH, int maxQueueSize) { return new Handlers.QueueLogMessageHandler(targetLMH, maxQueueSize); }
/// <summary>Creates a wrapper LMH that serves to Queue delivery of messages to the given targetLMH. Uses DefaultMesgQueueSize</summary> public static ILogMessageHandler CreateQueueLogMessageHandler(ILogMessageHandler targetLMH) { return CreateQueueLogMessageHandler(targetLMH, DefaultMesgQueueSize); }