/// <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> /// <param name="allowRecordSourceStackFrame">The use of this parameter is now obsolete and will be ignored</param> public QueueLogMessageHandler(string name, ILogMessageHandler[] targetLMHArray, int maxQueueSize = DefaultMesgQueueSize, bool allowRecordSourceStackFrame = false) : base(name, LogGate.None, recordSourceStackFrame: false) { targetLMHArray = targetLMHArray ?? emptyLMHArray; LogGate logGate = LogGate.None; foreach (ILogMessageHandler targetLMH in targetLMHArray) { logGate.MesgTypeMask |= targetLMH.LoggerConfig.LogGate.MesgTypeMask; } loggerConfig.LogGate = logGate; this.targetLMHArray = targetLMHArray; 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>Detailed Constructor. Uses given logger name, group name, and initialInstanceLogGate. Use default group name and enables instance trace logging</summary> /// <param name="name">Provides the LoggerName (source ID) to use for this logger.</param> /// <param name="groupName">Provides the GroupName that this logger name will be assigned/moved to</param> /// <param name="initialInstanceLogGate">Defines the initial instance group gate that may be more restrictive than the gate assigned to the group or the logger through the distribution system.</param> /// <param name="callerProvidedLMD">can be used to define the ILogMessageDistribution instance that this object will be used with</param> public QueuedLogger(string name, string groupName, LogGate initialInstanceLogGate, ILogMessageDistribution callerProvidedLMD = null) : base(name, groupName, initialInstanceLogGate, callerProvidedLMD: callerProvidedLMD) { dist4q = callerProvidedLMD ?? Logging.LogMessageDistribution.Instance; if (dist4q == null) { Utils.Asserts.TakeBreakpointAfterFault("{0}: LogMessageDistribution is null".CheckedFormat(ClassName)); } if (dist4q != null) { dist4q.StartQueuedMessageDeliveryIfNeeded(); } }
/// <summary>Creates a SimpleFileLogMessageHandler to write to the given filePath, and given LogGate value. Optionally includes files and line numbers. lmh name is "LMH." + filePath</summary> public static ILogMessageHandler CreateSimpleFileLogMessageHandler(string filePath, bool includeFileAndLines, LogGate logGate) { return new Handlers.SimpleFileLogMessageHandler(filePath, includeFileAndLines, logGate); }
/// <summary>Sets a gate level for messages to a given group so that it may be more restritive than that of the most permissive handler that is attached to the group.</summary> public static void SetDistributionGroupGate(string groupName, LogGate logGate) { GetLogMessageDistributionImpl().SetDistributionGroupGate(groupName, logGate); }
/// <summary> /// Use this method to read the stock set of ModularConfig points using the given configKeyPrefixStr and to update this ring configuration using the valid, non-zero values read from these keys. /// <para/>Keys are LogGate, DirectoryPath, MaxFilesToKeep, MaxFileAgeToKeepInDays, MaxTotalSizeToKeep, AdvanceAfterFileReachesSize, AdvanceAfterFileReachesAge /// </summary> public FileRotationLoggingConfig UpdateFromModularConfig(string configKeyPrefixStr, Logging.IMesgEmitter issueEmitter, Logging.IMesgEmitter valueEmitter) { ConfigValueSetAdapter<ConfigKeyValuesHelper> adapter = new ConfigValueSetAdapter<ConfigKeyValuesHelper>() { ValueSet = new ConfigKeyValuesHelper(), SetupIssueEmitter = issueEmitter, ValueNoteEmitter = valueEmitter }.Setup(configKeyPrefixStr); ConfigKeyValuesHelper configValues = adapter.ValueSet; logGate |= configValues.LogGate; if (!String.IsNullOrEmpty(configValues.DirectoryPath)) dirPath = configValues.DirectoryPath; if (configValues.MaxFilesToKeep != 0) purgeRules.dirNumFilesLimit = configValues.MaxFilesToKeep; if (configValues.MaxFileAgeToKeep != TimeSpan.Zero) purgeRules.FileAgeLimit = configValues.MaxFileAgeToKeep; if (configValues.MaxTotalSizeToKeep != 0) purgeRules.dirTotalSizeLimit = configValues.MaxTotalSizeToKeep; if (configValues.AdvanceAfterFileReachesSize != 0) advanceRules.fileSizeLimit = configValues.AdvanceAfterFileReachesSize; if (configValues.AdvanceAfterFileReachesAge != TimeSpan.Zero) advanceRules.FileAgeLimit = configValues.AdvanceAfterFileReachesAge; return this; }
/// <summary>Basic constructor.</summary> /// <param name="name">Defines the LMH name.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> /// <param name="lineFmt">Gives the line formatting rules that will be used for this LMH</param> public ConsoleLogMesssageHandler(string name, LogGate logGate, LineFormat lineFmt) : base(name, logGate, lineFmt, new System.IO.StreamWriter(Console.OpenStandardOutput()), true) { }
/// <summary>Creates a ConsoleLogMessageHandler named "LMH.Console" with given logGate</summary> public static ILogMessageHandler CreateConsoleLogMessageHandler(LogGate logGate) { return CreateConsoleLogMessageHandler("LMH.Console", logGate); }
/// <summary>Simple constructor: uses default settings of 2000 files in ring, 1000000 byes per file, DefaultMesgQueueSize</summary> public FileRotationLoggingConfig(string name, string dirPath, LogGate logGate) : this(name, dirPath, logGate, 2000, 1000000, DefaultMesgQueueSize) { }
/// <summary>Basic constructor.</summary> /// <param name="name">Defines the LMH name.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> /// <param name="lineFmt">Gives the line formatting rules that will be used for this LMH</param> /// <param name="ostream">Gives the StreamWriter instance to which the output text will be written.</param> /// <param name="flushAfterEachWrite">Set to true to flush the ostream after each write, or false to Flush only when explicitly told to by the LogDistribution system.</param> public StreamWriterLogMessageHandlerBase(string name, LogGate logGate, LineFormat lineFmt, System.IO.StreamWriter ostream, bool flushAfterEachWrite) : base(name, logGate, lineFmt.IncludeFileAndLine, true) { this.lineFmt = lineFmt; this.ostream = ostream; this.flushAfterEachWrite = flushAfterEachWrite; if (lineFmt == null) Utils.Asserts.TakeBreakpointAfterFault("LineFmt is null"); if (ostream == null) Utils.Asserts.TakeBreakpointAfterFault("ostream is null"); // add an action to close the ostream when this object is disposed. AddExplicitDisposeAction( () => { if (this.ostream != null) { this.ostream.Close(); this.ostream = null; } }); }
/// <summary>Basic constructor.</summary> /// <param name="appName">Gives the name of the appication that will be used as a prefix for the debug log messages that are generated</param> /// <param name="name">Defines the LMH name.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> public Win32DebugLogMessageHandler(string appName, string name, LogGate logGate) : base(name, logGate, false, true) { this.appName = appName; this.lineFmt = new LineFormat(false, true, true, true, true, false, "\n", " "); if (String.IsNullOrEmpty(appName)) Utils.Asserts.TakeBreakpointAfterFault("AppName is empty"); }
/// <summary>Basic constructor.</summary> /// <param name="name">Defines the LMH name.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> /// <param name="includeFileAndLines">Indicates if this handler should record and save source file and line numbers.</param> /// <param name="supportReferenceCountedRelease">Indicates if this logger supports reference counted log message release.</param> public SimpleLogMessageHandlerBase(string name, LogGate logGate, bool includeFileAndLines, bool supportReferenceCountedRelease) : base(name, logGate, includeFileAndLines, supportReferenceCountedRelease) { }
/// <summary>Basic constructor.</summary> /// <param name="filePath">Gives the path to the file name to which log messages will be appended. Also used to name the LMH instance as "LMH." + filePath</param> /// <param name="includeFileAndLines">Indicates if this handler should record and include source file and line numbers.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> public SimpleFileLogMessageHandler(string filePath, bool includeFileAndLines, LogGate logGate) : base("LMH." + filePath, logGate, new LineFormat(true, true, true, true, includeFileAndLines), new System.IO.StreamWriter(filePath, true, System.Text.Encoding.ASCII), false) { if (ostream.BaseStream.CanWrite) ostream.Write("\r\n"); logger.Signif.Emit("----------------------------------------"); logger.Signif.Emit("LogMessageHandler starting: File has been opened"); }
/// <summary>Basic constructor.</summary> /// <param name="name">Defines the LMH name.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> /// <param name="includeFileAndLines">Indicates if this handler should record and include source file and line numbers.</param> public NullLogMessageHandler(string name, LogGate logGate, bool includeFileAndLines) : base(name, logGate, includeFileAndLines, true) { }
/// <summary>Creates a Win32DebugLogMessageHandler named "LMH.Debug" with given logGate</summary> /// <remarks>appName is used to prefix all messages that are sent to the debugger</remarks> public static ILogMessageHandler CreateWin32DebugLogMessageHandler(string appName, LogGate logGate) { return CreateWin32DebugLogMessageHandler(appName, "LMH.Debug", logGate); }
/// <summary>Creates a ConsoleLogMessageHandler given name and logGate</summary> public static ILogMessageHandler CreateConsoleLogMessageHandler(string name, LogGate logGate) { return new Handlers.ConsoleLogMesssageHandler(name, logGate, new Handlers.LineFormat(false, true, true, " ")); }
/// <summary>Creates a Win32DebugLogMessageHandler given name and logGate</summary> /// <remarks>appName is used to prefix all messages that are sent to the debugger</remarks> public static ILogMessageHandler CreateWin32DebugLogMessageHandler(string appName, string name, LogGate logGate) { return new Handlers.Win32DebugLogMessageHandler(appName, name, logGate); }
/// <summary>Creates a DiagnosticTraceLogMessageHandler named "LMH.DiagnosticTrace" with given logGate</summary> public static ILogMessageHandler CreateDiagnosticTraceLogMessageHandler(LogGate logGate) { return CreateDiagnosticTraceLogMessageHandler("LMH.DiagnosticTrace", logGate); }
/// <summary>Standard constructor</summary> public FileRotationLoggingConfig(string name, string dirPath, LogGate logGate, int maxFilesInRing, int advanceAfterFileSize, int mesgQueueSize) : this() { this.name = name; this.dirPath = dirPath; this.logGate = logGate; this.mesgQueueSize = mesgQueueSize; this.nameUsesDateAndTime = true; this.includeFileAndLine = true; this.includeQpcTime = true; this.advanceRules = new AdvanceRules(); this.purgeRules = new PurgeRules(); purgeRules.dirNumFilesLimit = maxFilesInRing; advanceRules.fileSizeLimit = advanceAfterFileSize; advanceRules.fileAgeLimitInSec = 24.0 * 3600.0; // 1 day excludeFileNamesSet = new List<string>(); createDirectoryIfNeeded = true; }
/// <summary>Creates a DiagnosticTraceLogMessageHandler given name and logGate</summary> public static ILogMessageHandler CreateDiagnosticTraceLogMessageHandler(string name, LogGate logGate) { return new Handlers.DiagnosticTraceLogMessageHandler(name, logGate, new Handlers.LineFormat(false, true, true, true, true, false, "", " ")); }
/// <summary>Basic constructor.</summary> /// <param name="name">Defines the LMH name.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> /// <param name="includeFileAndLines">Indicates if this handler should record and save source file and line numbers.</param> /// <param name="supportReferenceCountedRelease">Indicates if this logger supports reference counted log message release.</param> public CommonLogMessageHandlerBase(string name, LogGate logGate, bool includeFileAndLines, bool supportReferenceCountedRelease) { this.name = name; loggerConfig = new LoggerConfig() { GroupName = "LMH:" + name, LogGate = logGate, RecordSourceStackFrame = includeFileAndLines, SupportsReferenceCountedRelease = supportReferenceCountedRelease }; logger = new LogMesgHandlerLogger(this); }
/// <summary>Creates a NullLogMessageHandler named "LMH.Null" with given logGate</summary> public static ILogMessageHandler CreateNullLogMessageHandler(LogGate logGate) { return CreateNullLogMessageHandler("LMH.Null", logGate); }
/// <summary>Basic constructor.</summary> /// <param name="name">Defines the LMH name.</param> /// <param name="logGate">Defines the LogGate value for messages handled here. Messages with MesgType that is not included in this gate will be ignored.</param> /// <param name="lineFmt">Gives the line formatting rules that will be used for this LMH</param> public DiagnosticTraceLogMessageHandler(string name, LogGate logGate, LineFormat lineFmt) : base(name, logGate, false, true) { this.lineFmt = lineFmt; }
/// <summary>Creates a NullLogMessageHandler given name and logGate</summary> public static ILogMessageHandler CreateNullLogMessageHandler(string name, LogGate logGate) { return new Handlers.NullLogMessageHandler(name, logGate, false); }
/// <summary>Sets the group gate level for the default distribution group.</summary> public static void SetDefaultDistributionGroupGate(LogGate logGate) { SetDistributionGroupGate(DefaultDistributionGroupName, logGate); }
/// <summary>Creates a SimpleFileLogMessageHandler to write to the given filePath, does not include files and lines, uses given LogGate. lmh name is "LMH." + filePath</summary> public static ILogMessageHandler CreateSimpleFileLogMessageHandler(string filePath, LogGate logGate) { return CreateSimpleFileLogMessageHandler(filePath, false, logGate); }
public void SetDistributionGroupGate(string groupName, LogGate logGate) { lock (distMutex) { int dgid = InnerGetDistGroupID(groupName, true); if (!InnerIsDistGroupIDValid(dgid)) { Utils.Asserts.TakeBreakpointAfterFault("SetDistributionGroupGate::Given GroupName could not be created."); return; } PerDistGroupIDInfo dgInfo = distGroupIDInfoList [dgid]; // read the LoggerConfig (struct), update the LogGate field and then write it back to the PerDistGroupIDInfo so that it can notify observers of the change. LoggerConfig lc = dgInfo.GroupLoggerConfigSetting; lc.LogGate = logGate; dgInfo.GroupLoggerConfigSetting = lc; if (dgInfo.UpdateActiveLoggerConfig()) InnerUpdateLoggerDistGroupConfigForGroup(dgid); } }
/// <summary>Constructor. Uses given logger name, and initialInstanceLogGate. Enables instance trace logging</summary> /// <param name="name">Provides the LoggerName (source ID) to use for this logger.</param> /// <param name="initialInstanceLogGate">Defines the initial instance group gate that may be more restrictive than the gate assigned to the group or the logger through the distribution system.</param> public QueuedLogger(string name, LogGate initialInstanceLogGate) : this(name, string.Empty, initialInstanceLogGate) { }