/// <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();
		}

		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);
		}

		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="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();
 }

        /// <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 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 });
		}

 /// <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;
 }

		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;
		}

 LoggingLevel(string name, int index, SourceLevels sourceLevel, TraceEventType traceEventType)
 {
     _name = name;
     _index = index;
     _sourceLevel = sourceLevel;
     _traceEventType = traceEventType;
 }

 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;
 }

        private EntLib.TraceSourceData GetAllEventsSource(SourceLevels level)
        {
            var source = new EntLib.TraceSourceData();
            source.DefaultLevel = level;
            this.AddEventLogTraceListenerReference(source);

            return source;
        }

 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();
 }

        /// <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;
        }

        public CustomTextTraceSource(string targetClassAndMethodName, string sourceName, SourceLevels defaultLevel) :
            base(sourceName, defaultLevel)
        {
            _targetClassAndMethodName = targetClassAndMethodName;

            TraceDateTime();
            TraceClassAndMethod();
        }

 /// <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;
 }

        static GitHubController()
        {
            var tracingLevel = ConfigurationManager.AppSettings["TracingLevel"];
            SourceLevels sourceLevel = SourceLevels.Information;
            Enum.TryParse<SourceLevels>(tracingLevel, out sourceLevel);

            traceLevel = sourceLevel;
        }

 public CouchbaseTraceListener(SourceLevels logLevel)
 {
     Level = logLevel;
     Name = "Couchbase";
     TraceOutputOptions = Level.HasFlag(SourceLevels.All)
         ? TraceOptions.ThreadId | TraceOptions.DateTime /*| TraceOptions.Timestamp*/
         :  TraceOptions.None;
 }

		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);
		}