/// <summary>
/// Initializes a new instance of the <see cref="TraceSourceSetting"/> class.
/// </summary>
/// <param name="sourceName">Name of the source.</param>
/// <param name="loggingLevel">The logging level.</param>
public TraceSourceSetting(string sourceName, SourceLevels loggingLevel)
{
Guard.NotNullOrEmpty(() => sourceName, sourceName);
this.SourceName = sourceName;
this.LoggingLevel = loggingLevel;
}
internal TraceManager()
{
this.defaultLogFolder = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData) + "\\Microsoft\\Care Suite\\Windows Device Recovery Tool\\Traces\\";
this.currentTracingLevel = SourceLevels.All;
this.Tracers = new List<IThreadSafeTracer>();
AppDomain.CurrentDomain.ProcessExit += new EventHandler(this.OnCurrentDomainProcessExit);
}
/// <summary>
/// Initializes a new instance of the <see cref="LogSourceData"/> class with the specified parameters.
/// </summary>
/// <param name="name">The name for the log source.</param>
/// <param name="level">The level for the log source.</param>
/// <param name="autoFlush"><see langword="true"/> to enable auto-flush; otherwise, <see langword="false"/>.</param>
/// <param name="traceListeners">One or more <see cref="TraceListener"/> objects.</param>
public LogSourceData(string name, SourceLevels level, bool autoFlush, params TraceListener[] traceListeners)
{
this.Name = name;
this.Level = level;
this.AutoFlush = autoFlush;
this.Listeners = traceListeners.ToList();
}
LoggingLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType)
{
_name = name;
_index = index;
_sourceLevel = sourceLevel;
_traceEventType = traceEventType;
}
internal TraceSourceInfo (string name, SourceLevels levels, TraceImplSettings settings)
{
this.name = name;
this.levels = levels;
this.listeners = new TraceListenerCollection ();
this.listeners.Add (new DefaultTraceListener() { IndentSize = settings.IndentSize });
}
private AssertNoBindingErrorsTraceListener(SourceLevels level)
{
WindowsRegistryAssert.HasDword(@"Software\Microsoft\Tracing\WPF", "ManagedTracing",1,"You need to add this key to your registry for Wpf report Binding Errors. \n" + RegEditText);
PresentationTraceSources.DataBindingSource.Listeners.Add(this);
PresentationTraceSources.DataBindingSource.Switch.Level = level;
}
/// <summary>
/// Initializes a new instance of the <see cref="LogSource"/> class with a name, a collection of <see cref="TraceListener"/>s, a level and the auto flush.
/// </summary>
/// <param name="name">The name for the instance.</param>
/// <param name="traceListeners">The collection of <see cref="TraceListener"/>s.</param>
/// <param name="level">The <see cref="SourceLevels"/> value.</param>
/// <param name="autoFlush">If Flush should be called on the Listeners after every write.</param>
public LogSource(string name, IEnumerable<TraceListener> traceListeners, SourceLevels level, bool autoFlush)
{
this.name = name;
this.traceListeners = new List<TraceListener>(traceListeners);
this.level = level;
this.autoFlush = autoFlush;
}
internal TraceSourceInfo (string name, SourceLevels levels, TraceImplSettings settings)
{
this.name = name;
this.levels = levels;
this.listeners = new TraceListenerCollection (false);
this.listeners.Add (new DefaultTraceListener(), settings);
}
LogLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType)
{
Name = name;
_index = index;
SourceLevel = sourceLevel;
TraceEventType = traceEventType;
}
/// <summary>
/// Initializes a new instance of the <see cref="LogSource"/> class with a name, a collection of <see cref="TraceListener"/>s and a level.
/// </summary>
/// <param name="name">The name for the instance.</param>
/// <param name="traceListeners">The collection of <see cref="TraceListener"/>s.</param>
/// <param name="level">The <see cref="SourceLevels"/> value.</param>
public LogSource(string name, List<TraceListener> traceListeners, SourceLevels level)
{
this.name = name;
this.traceListeners = traceListeners;
this.level = level;
this.instrumentationProvider = new LoggingInstrumentationProvider();
}
/// <summary>
/// Initializes the traceHandlerStreamWriter object
/// </summary>
/// <param name="traceSource">Trace source that holds a set of handlers</param>
/// <param name="filterLevels">The level of trace message filtered by trace listener</param>
/// <param name="traceOptions">Trace data options that has to be written in the trace output</param>
/// <param name="traceFileFormat">File format component for the handler</param>
/// <param name="fileExtension">Extension of trace file name for each handler</param>
public Writer(TraceSource traceSource, SourceLevels filterLevels, TraceOptions traceOptions, ITraceFileFormat traceFileFormat, string fileExtension = "txt")
{
this.traceSource = traceSource;
this.filterLevels = filterLevels;
this.traceOptions = traceOptions;
this.traceFileFormat = traceFileFormat;
this.fileExtension = fileExtension;
}
/// <summary>
/// Initializes the configured switches for <see cref="LogManager"/>.
/// </summary>
/// <param name="diagnosticsSection">The system.diagnostics configuration section.</param>
internal LogManager(ConfigurationSection diagnosticsSection)
{
SourceSwitch defaultSwitch;
configuredSources = GetConfiguredSources(diagnosticsSection);
configuredSwitches = GetConfiguredSwitches(diagnosticsSection);
defaultLevel = configuredSwitches.TryGetValue("default", out defaultSwitch) ? defaultSwitch.Level : SourceLevels.Warning;
}
internal PiiTraceSource(string name, string eventSourceName, SourceLevels levels)
: base(name, levels)
{
#pragma warning disable 618
Fx.Assert(!String.IsNullOrEmpty(eventSourceName), "Event log source name must be valid");
#pragma warning restore 618
this.eventSourceName = eventSourceName;
}
private EntLib.TraceSourceData GetAllEventsSource(SourceLevels level)
{
var source = new EntLib.TraceSourceData();
source.DefaultLevel = level;
this.AddEventLogTraceListenerReference(source);
return source;
}
public CouchbaseTraceListener(SourceLevels logLevel)
{
Level = logLevel;
Name = "Couchbase";
TraceOutputOptions = Level.HasFlag(SourceLevels.All)
? TraceOptions.ThreadId | TraceOptions.DateTime /*| TraceOptions.Timestamp*/
: TraceOptions.None;
}
public void WriteLine(SourceLevels level, string message, string category)
{
Console.Out.Write(String.Format("{0} {1}", LevelToString(level), category));
Console.Out.Write(": ");
Console.Out.Write(message);
Console.Out.Write(Environment.NewLine);
Console.Out.Flush();
}
public static void SetTraceLevel(LogCategory category, SourceLevels sourceLevel)
{
var sourceSwitch = new SourceSwitch(string.Format(CultureInfo.InvariantCulture, "MigSharp.{0}.Switch", category))
{
Level = sourceLevel
};
Sources[category].Switch = sourceSwitch;
}
static GitHubController()
{
var tracingLevel = ConfigurationManager.AppSettings["TracingLevel"];
SourceLevels sourceLevel = SourceLevels.Information;
Enum.TryParse<SourceLevels>(tracingLevel, out sourceLevel);
traceLevel = sourceLevel;
}
public CustomTextTraceSource(string targetClassAndMethodName, string sourceName, SourceLevels defaultLevel) :
base(sourceName, defaultLevel)
{
_targetClassAndMethodName = targetClassAndMethodName;
TraceDateTime();
TraceClassAndMethod();
}
public BREFactoryConsole(SourceLevels engineTraceLevel, SourceLevels ruleBaseTraceLevel) {
Logger.FlowEngineSource.Switch.Level = engineTraceLevel;
Logger.FlowEngineRuleBaseSource.Switch.Level = ruleBaseTraceLevel;
Logger.RefreshBooleanSwitches();
ConsoleTraceListener ctl = new ConsoleTraceListener();
Logger.FlowEngineSource.Listeners.Add(ctl);
Logger.FlowEngineRuleBaseSource.Listeners.Add(ctl);
}
public LogImplementation(SourceLevels level)
{
var factory = new LoggingConfigurationSourceFactory();
var configurationSource = factory.Create(level);
this.entLibSettings =
configurationSource.GetSection(EntLib.LoggingSettings.SectionName)
as EntLib.LoggingSettings;
this.logWriter = new LogWriterFactory(configurationSource).Create();
this.loggingEnabled = true;
}
public ThreadSafeTracer(string name, SourceLevels tracingLevel)
{
this.tracer = new TraceSource(name)
{
Switch = new SourceSwitch("Main switch")
{
Level = tracingLevel
}
};
}
private EntLib.LoggingSettings CreateLoggingSettings(SourceLevels level)
{
var entLibSettings = new EntLib.LoggingSettings();
this.AddFormatters(entLibSettings);
this.AddEventLogTraceListener(entLibSettings);
this.AddApplicationCategorySource(entLibSettings);
this.AddSpecialSources(level, entLibSettings);
return entLibSettings;
}
public static void SetTrace(SourceLevels level, TraceOptions options)
{
if (_listener == null)
{
_listener = new BindingErrorTraceListener();
PresentationTraceSources.DataBindingSource.Listeners.Add(_listener);
}
_listener.TraceOutputOptions = options;
PresentationTraceSources.DataBindingSource.Switch.Level = level;
}
public IConfigurationSource Create(SourceLevels level)
{
var loggingConfigSource = new DictionaryConfigurationSource();
var entLibSettings = this.CreateLoggingSettings(level);
if (entLibSettings != null)
{
loggingConfigSource.Add(EntLib.LoggingSettings.SectionName, entLibSettings);
}
return loggingConfigSource;
}
private static void UpdateLevel()
{
level = DiagnosticTrace.Level;
tracingEnabled = DiagnosticTrace.TracingEnabled;
shouldTraceCritical = DiagnosticTrace.ShouldTrace(TraceEventType.Critical);
shouldTraceError = DiagnosticTrace.ShouldTrace(TraceEventType.Error);
shouldTraceInformation = DiagnosticTrace.ShouldTrace(TraceEventType.Information);
shouldTraceWarning = DiagnosticTrace.ShouldTrace(TraceEventType.Warning);
shouldTraceVerbose = DiagnosticTrace.ShouldTrace(TraceEventType.Verbose);
shouldUseActivity = DiagnosticTrace.ShouldUseActivity;
}
/// <summary>
/// Prevents a default instance of the <see cref="Logger"/> class from being created.
/// </summary>
private Logger()
{
this.traceSources.Add(new TraceSource(WorkflowActivityLibraryLogSourceName));
this.traceSources.Add(new TraceSource(ResourceManagementLogSourceName));
this.traceSources.Add(new TraceSource(EventTracingForWindowsResourceManagementLogSourceName));
this.currentSourceLevel = SourceLevels.Off;
foreach (TraceSource ts in this.traceSources.Where(ts => this.currentSourceLevel < ts.Switch.Level))
{
this.currentSourceLevel = ts.Switch.Level;
}
}
/// <summary>
/// Gets the closest "parent" TraceRoute that has listeners, or null otherwise
/// </summary>
/// <param name="name"></param>
/// <param name="sourceLevels"></param>
/// <returns></returns>
private static TraceSource GetTraceSourceWithListenersSyncLock(string name, SourceLevels sourceLevels)
{
string[] splitters = name.Split(new char[] { '.' }, StringSplitOptions.None);
List<string> nameSplitList = new List<string>();
StringBuilder builder = new StringBuilder();
foreach (string split in splitters)
{
if (builder.Length > 0)
{
builder.Append(".");
}
builder.Append(split);
string partialName = builder.ToString();
nameSplitList.Add(partialName);
}
nameSplitList.Reverse();
foreach (string nameSplit in nameSplitList)
{
TraceSource sourceTrace = null;
sourceTrace = new TraceSource(nameSplit, sourceLevels);
if (sourceTrace.Listeners == null || sourceTrace.Listeners.Count == 0)
{
sourceTrace.Close();
continue;
}
if (sourceTrace.Listeners.Count > 1)
{
return sourceTrace;
}
TraceListener listenerTrace = sourceTrace.Listeners[0];
if (!(listenerTrace is DefaultTraceListener))
{
return sourceTrace;
}
if (!string.Equals(listenerTrace.Name, "Default", StringComparison.Ordinal))
{
return sourceTrace;
}
sourceTrace.Close();
}
return null;
}
protected override void OnSetLevel(SourceLevels level)
{
if (this.TraceSource != null)
{
if (this.TraceSource.Switch.Level != SourceLevels.Off &&
level == SourceLevels.Off)
{
TraceSource temp = this.TraceSource;
this.CreateTraceSource();
temp.Close();
}
this.shouldUseActivity = (level & SourceLevels.ActivityTracing) != 0;
}
}
/// <summary>Set/Update the trave level</summary>
/// <param name="level"></param>
public static void SetLevel(SourceLevels level)
{
lock (s_lock)
{
if (s_initialized) Close();
s_enabled = false;
if (level != SourceLevels.Off)
{
s_traceSource = new TraceSource("FoundationDB.Client", level);
s_enabled = true;
}
s_initialized = true;
}
}
// Constructors
public EventTypeFilter(SourceLevels level)
{
}
public ILoggingConfigurationSendToFlatFileTraceListener Filter(SourceLevels sourceLevel)
{
flatFileTracelistenerData.Filter = sourceLevel;
return(this);
}
public void WriteLine(SourceLevels level, string message, string category)
{
Level = level;
WriteLine(message, category);
}
public void TraceLevelIsEqualToPassedTraceLevel([Values] SourceLevels traceLevel)
{
var builder = IsDayOffSettings.Build.UseLogging(traceLevel).Create();
Assert.That(builder.TraceLevel, Is.EqualTo(traceLevel));
}
/// <summary>
/// Warning: this is not tread-safe, so only call this at startup or at a time that you are sure your
/// process is not performing any logging!
/// </summary>
/// <param name="filePath">The path to the log file.</param>
/// <param name="sourceLevels">The lowest log level to log.</param>
public static void SetLogFilePath(string filePath, SourceLevels sourceLevels)
{
if (!System.IO.Path.IsPathRooted(filePath))
{
filePath = System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
System.IO.Path.Combine(@"SatIp RtspSample\Logs", filePath));
}
Level level = Level.Debug;
if (_sourceLevels == SourceLevels.Information)
{
level = Level.Info;
}
else if (_sourceLevels == SourceLevels.Warning)
{
level = Level.Warn;
}
else if (_sourceLevels == SourceLevels.Error)
{
level = Level.Error;
}
else if (_sourceLevels == SourceLevels.Critical)
{
level = Level.Fatal;
}
_sourceLevels = sourceLevels;
var hierarchy =
(log4Hierarchy.Hierarchy)LogManager.GetAllRepositories().FirstOrDefault(r => r.Name == Path) ??
(log4Hierarchy.Hierarchy)LogManager.CreateRepository(Path);
hierarchy.Root.RemoveAllAppenders();
var roller = new RollingFileAppender();
var patternLayout = new PatternLayout {
ConversionPattern = "%date [%-5level][%thread]: %message%newline"
};
patternLayout.ActivateOptions();
roller.Layout = patternLayout;
roller.AppendToFile = true;
roller.RollingStyle = RollingFileAppender.RollingMode.Size;
roller.MaxSizeRollBackups = 4;
roller.MaximumFileSize = "1000KB";
roller.StaticLogFileName = true;
roller.File = filePath;
roller.ActivateOptions();
roller.AddFilter(new LevelRangeFilter
{
LevelMin = level,
LevelMax = Level.Fatal
});
BasicConfigurator.Configure(hierarchy, roller);
var coreLogger = hierarchy.GetLogger(Path) as log4Hierarchy.Logger;
if (coreLogger != null)
{
coreLogger.Level = level;
}
_log = LogManager.GetLogger(hierarchy.Name, Path);
}
/// <summary>
/// Initializes a new instance of the <see cref="System.Diagnostics.TraceSource"/> class.
/// </summary>
/// <param name="name">Name.</param>
/// <param name="level">Level.</param>
public TraceSource(string name, SourceLevels level)
{
//_tag = name;
this.Listeners = new List <TraceListener>();
}
public static IDisposable Start(SourceLevels level = SourceLevels.Warning)
{
var listener = new AssertNoBindingErrorsTraceListener(level);
return(new DisposableToken(listener));
}
/// <summary>
/// Initializes a new instance of the <see cref="MsmqTraceListenerData"/> class.
/// </summary>
/// <param name="name">The name for the represented trace listener.</param>
/// <param name="queuePath">The path name for the represented trace listener.</param>
/// <param name="formatterName">The formatter name for the represented trace listener.</param>
/// <param name="messagePriority">The priority for the represented trace listener.</param>
/// <param name="recoverable">The recoverable flag for the represented trace listener.</param>
/// <param name="timeToReachQueue">The timeToReachQueue for the represented trace listener.</param>
/// <param name="timeToBeReceived">The timeToReachQueue for the represented trace listener.</param>
/// <param name="useAuthentication">The use authentication flag for the represented trace listener.</param>
/// <param name="useDeadLetterQueue">The use dead letter flag for the represented trace listener.</param>
/// <param name="useEncryption">The use encryption flag for the represented trace listener.</param>
/// <param name="transactionType">The transaction type for the represented trace listener.</param>
/// <param name="traceOutputOptions">The trace output options for the represented trace listener.</param>
/// <param name="filter">The filter for the represented trace listener.</param>
public MsmqTraceListenerData(string name, string queuePath, string formatterName,
MessagePriority messagePriority, bool recoverable,
TimeSpan timeToReachQueue, TimeSpan timeToBeReceived,
bool useAuthentication, bool useDeadLetterQueue, bool useEncryption,
MessageQueueTransactionType transactionType, TraceOptions traceOutputOptions, SourceLevels filter)
: base(name, typeof(MsmqTraceListener), traceOutputOptions, filter)
{
this.QueuePath = queuePath;
this.Formatter = formatterName;
this.MessagePriority = messagePriority;
this.Recoverable = recoverable;
this.TimeToReachQueue = timeToReachQueue;
this.TimeToBeReceived = timeToBeReceived;
this.UseAuthentication = useAuthentication;
this.UseDeadLetterQueue = useDeadLetterQueue;
this.UseEncryption = useEncryption;
this.TransactionType = transactionType;
}
/// <summary>
/// Configures the specified trace source to write to a file.
/// </summary>
/// <param name="source">The trace source.</param>
/// <param name="filePath">The file path.</param>
/// <param name="levels">The trace levels.</param>
public static void Configure(string source, string filePath, SourceLevels levels)
{
StreamWriter textWriter = new StreamWriter(filePath, true);
Configure(source, textWriter, levels);
}
/// <summary>
/// Initializes a <see cref="EmailTraceListenerData"/> with a toaddress,
/// fromaddress, subjectLineStarter, subjectLineEnder, smtpServer, a formatter name, trace options
/// and authentication information.
/// </summary>
/// <param name="name">The name of this listener</param>
/// <param name="toAddress">A semicolon delimited string the represents to whom the email should be sent.</param>
/// <param name="fromAddress">Represents from whom the email is sent.</param>
/// <param name="subjectLineStarter">Starting text for the subject line.</param>
/// <param name="subjectLineEnder">Ending text for the subject line.</param>
/// <param name="smtpServer">The name of the SMTP server.</param>
/// <param name="smtpPort">The port on the SMTP server to use for sending the email.</param>
/// <param name="formatterName">The name of the Formatter <see cref="ILogFormatter"/> which determines how the
///email message should be formatted</param>
/// <param name="traceOutputOptions">The trace options.</param>
/// <param name="filter">The filter to apply.</param>
/// <param name="authenticationMode">Authenticate mode to use.</param>
/// <param name="userName">User name to pass to the server if using <see cref="EmailAuthenticationMode.UserNameAndPassword"/>.</param>
/// <param name="password">Password to pass to the server if using <see cref="EmailAuthenticationMode.UserNameAndPassword"/>.</param>
/// <param name="useSSL">Connect to the server using SSL?</param>
public EmailTraceListenerData(string name,
string toAddress, string fromAddress,
string subjectLineStarter, string subjectLineEnder,
string smtpServer, int smtpPort,
string formatterName, TraceOptions traceOutputOptions, SourceLevels filter,
EmailAuthenticationMode authenticationMode, string userName, string password, bool useSSL)
: base(name, typeof(EmailTraceListener), traceOutputOptions, filter)
{
this.ToAddress = toAddress;
this.FromAddress = fromAddress;
this.SubjectLineStarter = subjectLineStarter;
this.SubjectLineEnder = subjectLineEnder;
this.SmtpServer = smtpServer;
this.SmtpPort = smtpPort;
this.Formatter = formatterName;
this.AuthenticationMode = authenticationMode;
this.UserName = userName;
this.Password = password;
this.UseSSL = useSSL;
}
/// <summary>
/// Initializes a <see cref="EmailTraceListenerData"/> with a toaddress,
/// fromaddress, subjectLineStarter, subjectLineEnder, smtpServer, a formatter name and trace options.
/// </summary>
/// <param name="name">The name of this listener</param>
/// <param name="toAddress">A semicolon delimited string the represents to whom the email should be sent.</param>
/// <param name="fromAddress">Represents from whom the email is sent.</param>
/// <param name="subjectLineStarter">Starting text for the subject line.</param>
/// <param name="subjectLineEnder">Ending text for the subject line.</param>
/// <param name="smtpServer">The name of the SMTP server.</param>
/// <param name="smtpPort">The port on the SMTP server to use for sending the email.</param>
/// <param name="formatterName">The name of the Formatter <see cref="ILogFormatter"/> which determines how the
///email message should be formatted</param>
/// <param name="traceOutputOptions">The trace options.</param>
/// <param name="filter">The filter to apply.</param>
public EmailTraceListenerData(string name, string toAddress, string fromAddress, string subjectLineStarter, string subjectLineEnder, string smtpServer, int smtpPort, string formatterName, TraceOptions traceOutputOptions, SourceLevels filter)
: base(name, typeof(EmailTraceListener), traceOutputOptions, filter)
{
this.ToAddress = toAddress;
this.FromAddress = fromAddress;
this.SubjectLineStarter = subjectLineStarter;
this.SubjectLineEnder = subjectLineEnder;
this.SmtpServer = smtpServer;
this.SmtpPort = smtpPort;
this.Formatter = formatterName;
}
public ILoggingConfigurationSendToSystemDiagnosticsTraceListener Filter(SourceLevels sourceLevel)
{
systemDiagnosticsData.Filter = sourceLevel;
return(this);
}
public MonoDevelopTracer(string name, SourceLevels level = SourceLevels.Warning)
{
Source = new TraceSource(name);
Level = level;
}
public void SetTracingLevel(string sourceName, SourceLevels level)
{
GetOrAdd(sourceName).Switch.Level = level;
}
private AssertNoBindingErrorsTraceListener(SourceLevels level)
{
WindowsRegistryAssert.HasDword(@"Software\Microsoft\Tracing\WPF", "ManagedTracing", 1, "You need to add this key to your registry for Wpf report Binding Errors. \n" + RegEditText);
PresentationTraceSources.DataBindingSource.Listeners.Add(this);
PresentationTraceSources.DataBindingSource.Switch.Level = level;
}
public static void SetDebugLevel(SourceLevels swlvl = SourceLevels.Information)
{
_trace.Switch.Level = swlvl;
_trace.TraceEvent(TraceEventType.Verbose, 0, "Created Merger");
}
public TraceSourceInfo(string name, SourceLevels levels)
{
this.name = name;
this.levels = levels;
this.listeners = new TraceListenerCollection();
}
private void AddTraceSource(IDictionary d, Hashtable sources, XmlNode node)
{
string name = null;
SourceLevels levels = SourceLevels.Error;
StringDictionary atts = new StringDictionary();
foreach (XmlAttribute a in node.Attributes)
{
switch (a.Name)
{
case "name":
name = a.Value;
break;
case "switchValue":
levels = (SourceLevels)Enum.Parse(typeof(SourceLevels), a.Value);
break;
default:
atts [a.Name] = a.Value;
break;
}
}
if (name == null)
{
throw new ConfigurationException("Mandatory attribute 'name' is missing in 'source' element.");
}
// ignore duplicate ones (no error occurs)
if (sources.ContainsKey(name))
{
return;
}
TraceSourceInfo sinfo = new TraceSourceInfo(name, levels, configValues);
sources.Add(sinfo.Name, sinfo);
foreach (XmlNode child in node.ChildNodes)
{
XmlNodeType t = child.NodeType;
if (t == XmlNodeType.Whitespace || t == XmlNodeType.Comment)
{
continue;
}
if (t == XmlNodeType.Element)
{
if (child.Name == "listeners")
{
AddTraceListeners(d, child, sinfo.Listeners);
}
else
{
ThrowUnrecognizedElement(child);
}
ValidateInvalidAttributes(child.Attributes, child);
}
else
{
ThrowUnrecognizedNode(child);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TraceSourceForEventSource" /> class.
/// </summary>
public TraceSourceForEventSource(SourceLevels defaultLevel)
: base(TraceSourceName, defaultLevel)
{
this.listener = new DiagnosticsEventListener(GetEventLevelFromSourceLevels(defaultLevel), (EventKeywords)AllKeyword, this);
}
public TraceSource(string name, SourceLevels defaultLevel)
{
}
public TraceSource(string name, SourceLevels level)
{
}
public BilgeConditionalRoutedBase(BilgeRouter rt, ConfigSettings cs, SourceLevels yourTraceLevel) : base(rt, cs)
{
activeTraceLevel = yourTraceLevel;
}
public static Tracer GetTracer(Type type, SourceLevels defaultLevel)
{
return(Tracer.GetTracer(type.FullName, defaultLevel));
}
/// <summary>
/// Bilge provides developer level trace to provide runtime diagnostics to developers.
/// </summary>
/// <param name="selectedInstanceContext">The context for this particular instance of bilge, usually used to identify a subsystem</param>
/// <param name="sessionContext">The context for a session, usually used to identify the user request</param>
/// <param name="tl">The trace level to set this instance of bilge to</param>
/// <param name="resetDefaults">Reset all pf the internal context of Bilge</param>
public Bilge(string selectedInstanceContext = "-", string sessionContext = "-", SourceLevels tl = SourceLevels.Off, bool resetDefaults = false)
{
activeConfig = new ConfigSettings();
activeConfig.InstanceContext = selectedInstanceContext;
activeConfig.SessionContext = sessionContext;
string procId = Process.GetCurrentProcess().Id.ToString();
if (resetDefaults)
{
BilgeRouter.Router.ClearEverything();
}
Assert = new BilgeAssert(BilgeRouter.Router, activeConfig);
Info = new InfoWriter(BilgeRouter.Router, activeConfig, SourceLevels.Information | SourceLevels.Error | SourceLevels.Critical);
Verbose = new VerboseWriter(BilgeRouter.Router, activeConfig, SourceLevels.All);
Warning = new WarningWriter(BilgeRouter.Router, activeConfig, SourceLevels.Warning | SourceLevels.Error | SourceLevels.Critical);
Error = new ErrorWriter(BilgeRouter.Router, activeConfig, SourceLevels.Error | SourceLevels.Critical);
Critical = new ErrorWriter(BilgeRouter.Router, activeConfig, SourceLevels.Critical);
Direct = new BilgeDirect(BilgeRouter.Router, activeConfig);
Util = new BilgeUtil(BilgeRouter.Router, activeConfig);
var level = levelResolver(selectedInstanceContext, tl);
SetTraceLevel(level);
}
protected TraceListenerNode(TraceOptions traceOptions, SourceLevels filter)
{
this.filter = filter;
this.traceOptions = traceOptions;
}
public Log4netTraceFilter(SourceLevels level)
{
_traceLevel = level;
}
protected virtual void OnSetLevel(SourceLevels level)
{
}
public CustomLogger(SourceLevels logLevel)
{
level = logLevel;
ts = new CouchbaseTraceListener(logLevel);
}
public EventTypeFilter(SourceLevels eventType)
{
event_type = eventType;
}
public LogTraceSource(string name, SourceLevels level)
: base(name, level)
{
}
