implab/ImplabNet Commit - r286:67ebcfd7d1c8

Working on Implab.Diagnostics

cin -

r286:67ebcfd7d1c8 v3

parent child

Context file:

r286:67ebcfd7d1c8

Collapse all files

Implab/Diagnostics/TraceChannel.cs created 644 +17 0

@@ -0,0 +1,17
	1	namespace Implab.Diagnostics
	2	{
	3	public abstract class TraceChannel {
	4	readonly object m_id;
	5
	6	public object Id {
	7	get {
	8	return m_id;
	9	}
	10	}
	11
	12	protected TraceChannel(object id) {
	13	m_id = id ?? new object();
	14	}
	15
	16	}
	17	} No newline at end of file

Implab/Diagnostics/TraceRegistry.cs created 644 +83 0

@@ -0,0 +1,83
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Diagnostics;
	4	using Implab.Parallels;
	5
	6	namespace Implab.Diagnostics {
	7	public class TraceRegistry {
	8
	9	class Subscription : IDisposable {
	10	readonly WeakReference<TraceRegistry> m_registry;
	11	readonly Action<object> m_unsubscribe;
	12
	13	public Subscription(TraceRegistry registry) {
	14	m_registry = new WeakReference<TraceRegistry>(registry);
	15	}
	16
	17	public void Dispose() {
	18	TraceRegistry t;
	19	if (m_registry.TryGetTarget(out t))
	20	t.RemoveSubscription(this);
	21	}
	22	}
	23
	24	public static TraceRegistry Global { get; } = new TraceRegistry();
	25
	26	readonly object m_lock = new object();
	27
	28	readonly Dictionary<object, Action<TraceChannel>> m_subscriptions = new Dictionary<object, Action<TraceChannel>>();
	29	readonly SimpleAsyncQueue<TraceChannel> m_channels = new SimpleAsyncQueue<TraceChannel>();
	30
	31	internal void Register(TraceChannel channel) {
	32	// notifications can run in parallel
	33	Action<TraceChannel>[] handlers = null;
	34
	35	lock(m_lock) {
	36	m_channels.Enqueue(channel);
	37	if (m_subscriptions.Count > 0) {
	38	handlers = new Action<TraceChannel>[m_subscriptions.Count];
	39	m_subscriptions.Values.CopyTo(handlers, 0);
	40	}
	41	}
	42
	43	if (handlers != null)
	44	foreach(var h in handlers)
	45	h(channel);
	46	}
	47
	48	/// <summary>
	49	/// Subscribes the specified handler to notifications about new trace
	50	/// channels
	51	/// </summary>
	52	/// <param name="handler"></param>
	53	/// <returns></returns>
	54	public IDisposable Subscribe(Action<TraceChannel> handler, bool existing) {
	55	Safe.ArgumentNotNull(handler, nameof(handler));
	56
	57	var cookie = new Subscription(this);
	58
	59	IEnumerable<TraceChannel> snap;
	60
	61	// lock to ensure that no new channels will be added
	62	// while the subscription is added
	63	lock(m_lock) {
	64	m_subscriptions.Add(cookie, handler);
	65	snap = m_channels.Snapshot();
	66	}
	67
	68	// announce previously declared channels if required
	69	if (existing) {
	70	foreach(var c in snap)
	71	handler(c);
	72	}
	73
	74	// return the subscription
	75	return cookie;
	76	}
	77
	78	void RemoveSubscription(object cookie) {
	79	lock(m_lock)
	80	m_subscriptions.Remove(cookie);
	81	}
	82	}
	83	} No newline at end of file

Implab/Diagnostics/TraceSourceChannel.cs created 644 +27 0

@@ -0,0 +1,27
	1	using TraceSource = System.Diagnostics.TraceSource;
	2
	3	namespace Implab.Diagnostics {
	4
	5	/// <summary>
	6	/// Trace channel which incapsulates <see cref="System.Diagnostics.TraceSource"/> instance.
	7	/// </summary>
	8	public class TraceSourceChannel : TraceChannel {
	9	readonly TraceSource m_trace;
	10
	11	public TraceSourceChannel() : base(new object()) {
	12	}
	13
	14	public TraceSourceChannel(object id) : base(id) {
	15	}
	16
	17	public TraceSourceChannel(object id, string name) : base(id) {
	18	m_trace = new TraceSource(name);
	19	}
	20
	21	public TraceSource Source {
	22	get {
	23	return m_trace;
	24	}
	25	}
	26	}
	27	} No newline at end of file

Implab/Diagnostics/TraceSourceChannel`1.cs created 644 +33 0

@@ -0,0 +1,33
	1	using System;
	2	using System.Threading;
	3	using TraceSource = System.Diagnostics.TraceSource;
	4
	5	namespace Implab.Diagnostics {
	6	/// <summary>
	7	/// This class is used to provide a single <see cref="TraceSourceChannel"/>
	8	/// instance for the specified class in <typeparamref name="T"/> parameter.
	9	/// </summary>
	10	/// <typeparam name="T">
	11	/// The class for which <see cref="TraceSourceChannel"/> is required.
	12	/// </typeparam>
	13	/// <remarks>
	14	/// The <see cref="TraceSourceChannel"/> instance will be created on demand
	15	/// and automatically registered in <see cref="TraceRegistry.Global"/>.
	16	/// </remarks>
	17	public static class TraceSourceChannel<T> {
	18	static Lazy<TraceSourceChannel> _traceSource = new Lazy<TraceSourceChannel>(CreateChannel, LazyThreadSafetyMode.ExecutionAndPublication);
	19
	20	/// <summary>
	21	/// The default <see cref="TraceSourceChannel"/> instance.
	22	/// </summary>
	23	public static TraceSourceChannel Default { get { return _traceSource.Value; } }
	24
	25	static TraceSourceChannel CreateChannel() {
	26	var channel = new TraceSourceChannel(typeof(T), typeof(T).Name);
	27
	28	TraceRegistry.Global.Register(channel);
	29
	30	return channel;
	31	}
	32	}
	33	} No newline at end of file

Implab.Playground/Program.cs +8 -125

@@ -1,155 +1,38
1	using System;	1	using System;
2	using System.Collections.Generic;	2	using System.Collections.Generic;
3	using System.Diagnostics;	3	using System.Diagnostics;
4	using System.Dynamic;	4	using System.Dynamic;
5	using System.Linq;	5	using System.Linq;
6	using Implab.Components;	6	using Implab.Components;
7	using Implab.Diagnostics;	7	using Implab.Diagnostics;
8	using Implab.ServiceHost.Unity;	8	using Implab.ServiceHost.Unity;
9	using Implab.Xml;	9	using Implab.Xml;
10	using Unity;	10	using Unity;
11	using Unity.Injection;	11	using Unity.Injection;
12	using Unity.Registration;	12	using Unity.Registration;
13		13
14	namespace Implab.Playground {	14	namespace Implab.Playground {
15		15	using static Trace<Bar>;
16	public class Foo {
17
18	public class Bar {
19
20	}
21
22	public string Name { get; set; }
23
24	public int IntValue { get; set; }
25
26	public string StringValue { get; set; }
27
28	public void AddRange(Foo[] items) {
29	Console.WriteLine($"AddRange: Foo[]");
30	}
31
32	}
33
34	public class FooFactory : IFactory<Foo>, IFactory<Foo.Bar> {
35
36	public bool UseSsl { get; set; }
37
38	public string Connection { get; set; }
39		16
40	public Foo Create() {	17	class Foo {
41	return new Foo() {
42	Name = "AutoFac"
43	};
44	}
45
46	Foo.Bar IFactory<Foo.Bar>.Create() {
47	return new Foo.Bar();
48	}
49	}
50
51	public interface IContainer<T> {
52	T Instance { get; set; }
53	}
54
55	public class Container<T> : IContainer<T> {
56	public class Bar {
57
58	}
59
60	public class Bar<T2> {
61	public class Baz {
62
63	}
64
65	}
66
67	public Container() {
68		18
69	}	19	}
70		20
71	public Container(T instance) {	21	class Bar : Foo {
72	Instance = instance;
73	}
74
75	public T Instance { get; set; }
76
77	public void SetInstance(T value) {
78	Instance = value;
79	}
80		22
81	public void AddRange(List<T> items) {
82	Console.WriteLine($"AddRange: {typeof(List<T>)}");
83	}	23	}
84
85	public void AddRange(T[] items) {
86	Console.WriteLine($"AddRange: T[] ofType {typeof(T[])}");
87	}
88	}
89
90	public class Program {	24	public class Program {
91		25
92	static void Main(string[] args) {	26	static void Main(string[] args) {
93	var u1 = new Uri("/some/one");
94		27
95	dynamic obj = new ExpandoObject();	28	using(TraceRegistry.Global.Subscribe(ch => {
96		29	Console.WriteLine($"{ch.Id}: {ch.Source.Name}");
97	obj.Name = "Dynamo";	30	}, true)) {
98		31	Trace<Foo>.Log("Hi!");
99	obj.Hello = new Func<string>(() => { return "Hello"; });	32	Log("Respect!");
100
101	Console.WriteLine($"{obj.Hello()}");
102
103	}
104
105	static void Main2(string[] args) {
106	var listener = new SimpleTraceListener(Console.Out);
107	var source = Trace<TypeResolver>.TraceSource;
108	source.Switch.Level = SourceLevels.All;
109	source.Listeners.Add(listener);
110
111	var stopwatch = new Stopwatch();
112	stopwatch.Start();
113
114	var container = new UnityContainer();
115
116	Console.WriteLine($"Created: {stopwatch.ElapsedMilliseconds}");
117	stopwatch.Restart();
118
119	container.LoadXmlConfiguration("data/sample.xml");
120
121	Console.WriteLine($"Loaded: {stopwatch.ElapsedMilliseconds}");
122
123	stopwatch.Restart();
124	var instace1 = container.Resolve<IContainer<string>>();
125	Console.WriteLine($"Resolved1: {stopwatch.ElapsedMilliseconds}");
126
127	stopwatch.Restart();
128	var instace2 = container.Resolve<IContainer<Foo>>();
129	Console.WriteLine($"Resolved2: {stopwatch.ElapsedMilliseconds}");
130
131	DisplayContainerRegistrations(container);
132	}
133
134	static void DisplayContainerRegistrations(IUnityContainer theContainer) {
135	string regName, regType, mapTo, lifetime;
136	Console.WriteLine("Container has {0} Registrations:",
137	theContainer.Registrations.Count());
138	foreach (ContainerRegistration item in theContainer.Registrations) {
139	regType = item.RegisteredType.FullName;
140	mapTo = item.MappedToType.FullName;
141	regName = item.Name ?? "[default]";
142	lifetime = item.LifetimeManager.LifetimeType.Name;
143	if (mapTo != regType) {
144	mapTo = " -> " + mapTo;
145	} else {
146	mapTo = string.Empty;
147	}
148	lifetime = lifetime.Substring(0, lifetime.Length - "LifetimeManager".Length);
149	Console.WriteLine("+ {0}{1} '{2}' {3}", regType, mapTo, regName, lifetime);
150	}	33	}
151	}	34	}
152		35
153		36
154	}	37	}
155	}	38	}

Implab.ServiceHost/Unity/ContainerBuilder.cs +4 -2

             using System;
             using System.IO;
             using System.Reflection;
             using Implab.Diagnostics;
             using Unity;
             namespace Implab.ServiceHost.Unity {
-                using static Trace<ContainerBuilder>;
+                using Log = Trace<ContainerBuilder>;
                 public class ContainerBuilder {
                     readonly TypeResolver m_resolver;
                     readonly IUnityContainer m_container;
                     readonly ContainerConfigurationSchema m_schema;
                     Uri m_location;
                     public IUnityContainer Container {
                         get {
                             return m_container;
                         }
                     }
                     public ContainerBuilder() : this(null, null) {
                     }
                     public ContainerBuilder(IUnityContainer container, ContainerConfigurationSchema schema) {
                         m_container = container ?? new UnityContainer();
                         m_resolver = new TypeResolver();
                         m_schema = schema ?? ContainerConfigurationSchema.Default;
                     }
                     public Type ResolveType(string typeReference) {
-                        return string.IsNullOrEmpty(typeReference) ? null : m_resolver.Resolve(typeReference, true);
+                        var resolved = string.IsNullOrEmpty(typeReference) ? null : m_resolver.Resolve(typeReference, true);
+                        Log.Debug("ResolveType('{0}'): {1}", typeReference, resolved?.FullName);
+                        return resolved;
                     }
                     public void Visit(ITypeRegistration registration) {
                         Safe.ArgumentNotNull(registration, nameof(registration));
                         var registrationType = registration.GetRegistrationType(this);
                         var implementationType = registration.GetImplementationType(this) ?? registrationType;
                         if (registrationType == null)
                             throw new Exception($"A type must be specified for the registration {registration.Name}");
                         var builder = new TypeRegistrationBuilder(
                             m_resolver,
                             registrationType,
                             implementationType
                         );
                         builder.Lifetime = registration.GetLifetime(this);
                         if (registration.MemberInjections != null) {
                             foreach(var member in registration.MemberInjections)
                                 member.Visit(builder);
                         }
                         m_container.RegisterType(
                             builder.RegistrationType,
                             builder.ImplementationType,
                             registration.Name,
                             builder.Lifetime,
                             builder.Injections
                         );
                     }
                     public void Visit(IInstanceRegistration registration) {
                         Safe.ArgumentNotNull(registration, nameof(registration));
                         var registrationType = registration.GetRegistrationType(this);
                         var builder = new InstanceRegistrationBuilder (
                             m_resolver,
                             registrationType
                         );
                         builder.Lifetime = registration.GetLifetime(this);
                         if (registration.MemberInjections != null) {
                             foreach(var member in registration.MemberInjections)
                                 member.Visit(builder.ValueBuilder);
                         }
                         if (builder.RegistrationType == null && builder.ValueBuilder.ValueType == null)
                             throw new Exception($"A type must be specified for the registration {registration.Name}");
                         m_container.RegisterInstance(
                             builder.RegistrationType ?? builder.ValueBuilder.ValueType,
                             registration.Name,
                             builder.ValueBuilder.Value,
                             builder.Lifetime
                         );
                     }
                     public void AddNamespace(string ns) {
                         m_resolver.AddNamespace(ns);
                     }
                     public void AddAssembly(string assembly) {
                     }
                     /// <summary>
                     /// Includes the confguration. Creates a new <see cref="ContainerBuilder"/>,
                     /// and loads the configuration to it. The created builder will share the
                     /// container and will have its own isolated type resolver.
                     /// </summary>
                     /// <param name="file">A path to configuration relative to the current configuration.</param>
                     public void Include(string file) {
                         var includeContext = new ContainerBuilder(m_container, m_schema);
                         if (m_location != null) {
                             var uri =  new Uri(m_location, file);
                             includeContext.LoadConfig(uri);
                         } else {
                             includeContext.LoadConfig(file);
                         }
                     }
                     /// <summary>
                     /// Loads a configuration from the specified local file.
                     /// </summary>
                     /// <param name="file">The path to the configuration file.</param>
                     public void LoadConfig(string file) {
                         Safe.ArgumentNotEmpty(file, nameof(file));
                         LoadConfig(new Uri(Path.GetFullPath(file)));
                     }
                     public void LoadConfig(Uri location) {
                         Safe.ArgumentNotNull(location, nameof(location));
                         m_location = location;
                         var config = m_schema.LoadConfig(location.ToString());
                         config.Visit(this);
                     }
                 }
             }

Implab/Diagnostics/LogicalOperation.cs +13 -3

             using System;
-            using System.Diagnostics;
+            using Stopwatch = System.Diagnostics.Stopwatch;
             namespace Implab.Diagnostics {
                 public class LogicalOperation {
-                    public Stopwatch OperationStopwatch { get; private set; }
+                    readonly Stopwatch m_stopwatch;
                     public string Name { get; private set; }
                     internal LogicalOperation(string name) {
                         Name = string.IsNullOrEmpty(name) ? "<unnamed>" : name;
-                        OperationStopwatch = Stopwatch.StartNew();
+                        m_stopwatch = Stopwatch.StartNew();
+                    }
+                    public TimeSpan Elapsed {
+                        get {
+                            return m_stopwatch.Elapsed;
+                        }
+                    }
+                    public void End() {
+                        m_stopwatch.Stop();
                     }
                     public override string ToString() => Name;
                 }
             }

Implab/Diagnostics/LogicalOperationScope.cs +1 -1

             using System;
             using System.Diagnostics;
             namespace Implab.Diagnostics {
                 public class LogicalOperationScope : IDisposable {
                     readonly TraceSource m_source;
                     readonly LogicalOperation m_operation;
                     internal LogicalOperationScope(TraceSource source, LogicalOperation operation) {
                         m_source = source;
                         m_operation = operation;
                     }
                     public void Dispose() {
-                        m_operation.OperationStopwatch.Stop();
+                        m_operation.End();
                         Trace.CorrelationManager.StopLogicalOperation();
                         m_source.TraceData(TraceEventType.Information, TraceEventCodes.StopLogicalOperation, m_operation);
                     }
                 }
             }

Implab/Diagnostics/SimpleTraceListener.cs +2 -2

             using System;
             using System.Diagnostics;
             using System.IO;
             namespace Implab.Diagnostics {
                 public class SimpleTraceListener : TextWriterTraceListener {
                     public SimpleTraceListener() {
                     }
                     public SimpleTraceListener(Stream stream) : base(stream) {
                     }
                     public SimpleTraceListener(TextWriter writer) : base(writer) {
                     }
                     public SimpleTraceListener(string fileName) : base(fileName) {
                     }
                     public SimpleTraceListener(Stream stream, string name) : base(stream, name) {
                     }
                     public SimpleTraceListener(TextWriter writer, string name) : base(writer, name) {
                     }
                     public SimpleTraceListener(string fileName, string name) : base(fileName, name) {
                     }
                     public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data) {
                         switch (id) {
                             case TraceEventCodes.StartLogicalOperation:
                                 TraceEvent(eventCache, source, eventType, id, "+{0}", data);
                                 break;
                             case TraceEventCodes.StopLogicalOperation:
                                 TraceEvent(eventCache, source, eventType, id, FormatStopLogicalOperation(data));
                                 break;
                             default:
                                 TraceEvent(eventCache, source, eventType, id, data?.ToString());
                                 break;
                         }
                     }
                     string FormatStopLogicalOperation(object data) {
                         if (data is LogicalOperation op) {
-                            return string.Format("-{0} ({1})", op, FormatTimespan(op.OperationStopwatch.Elapsed));
+                            return string.Format("-{0} ({1})", op, FormatTimespan(op.Elapsed));
                         } else {
                             return data?.ToString();
                         }
                     }
                     string FormatTimespan(TimeSpan value) {
                         if (value.TotalSeconds < 10) {
                             return value.Milliseconds.ToString() + "ms";
                         } else if (value.TotalSeconds < 30) {
                             return string.Format("{0:0.###}s", value.TotalSeconds);
                         } else {
                             return value.ToString();
                         }
                     }
                     public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, params object[] data) {
                         var prev = IndentLevel;
                         IndentLevel += eventCache.LogicalOperationStack.Count;
                         try {
                             base.TraceData(eventCache, source, eventType, id, data);
                         } finally {
                             IndentLevel = prev;
                         }
                     }
                     public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id) {
                         var prev = IndentLevel;
                         IndentLevel += eventCache.LogicalOperationStack.Count;
                         try {
                             base.TraceEvent(eventCache, source, eventType, id);
                         } finally {
                             IndentLevel = prev;
                         }
                     }
                     public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string format, params object[] args) {
                         TraceEvent(eventCache, source, eventType, id, String.Format(format, args));
                     }
                     public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message) {
                         var prev = IndentLevel;
                         IndentLevel += eventCache.LogicalOperationStack.Count;
                         try {
                             LogicalOperation operation = null;
                             if (eventCache.LogicalOperationStack.Count > 0)
                                 operation = eventCache.LogicalOperationStack.Peek() as LogicalOperation;
                             if (operation != null) {
-                                base.TraceData(eventCache, source, eventType, id, FormatTimespan(operation.OperationStopwatch.Elapsed) + ": " + message);
+                                base.TraceData(eventCache, source, eventType, id, FormatTimespan(operation.Elapsed) + ": " + message);
                             } else {
                                 base.TraceData(eventCache, source, eventType, id, message);
                             }
                         } finally {
                             IndentLevel = prev;
                         }
                     }
                     public override void TraceTransfer(TraceEventCache eventCache, string source, int id, string message, Guid relatedActivityId) {
                         var prev = IndentLevel;
                         IndentLevel += eventCache.LogicalOperationStack.Count;
                         try {
                             base.TraceTransfer(eventCache, source, id, message, relatedActivityId);
                         } finally {
                             IndentLevel = prev;
                         }
                     }
                 }
             }

Implab/Diagnostics/Trace.cs +49 -17

             // enable System.Diagnostics trace methods
             #define TRACE
             using System;
             using System.Collections.Generic;
             using System.Diagnostics;
             using System.Linq;
             using System.Text;
             using System.Threading;
             using System.Threading.Tasks;
             namespace Implab.Diagnostics {
+                /// <summary>
+                /// Static class which creates an individual <see cref="TraceSource"/> for
+                /// the type specified in the parameter <typeparamref name="T"/>.
+                /// </summary>
+                /// <typeparam name="T">The type for which tracing is demanded.</typeparam>
                 public static class Trace<T> {
-                    static Lazy<TraceSource> _traceSource = new Lazy<TraceSource>(CreateChannel, LazyThreadSafetyMode.ExecutionAndPublication);
+                    readonly static Lazy<TraceSource> _trace = new Lazy<TraceSource>(() => TraceSourceChannel<T>.Default.Source);
-                    static int _nextId;
-                    static TraceSource CreateChannel() {
+                    public static TraceSource TraceSource { get { return _trace.Value; } }
-                        var id = Interlocked.Increment(ref _nextId);
-                        var trs = new TraceSource(typeof(T).Name);
-                        TraceChannelRegistry.AllCannels.NotifyChannelCreated(new ChannelInfo(typeof(T), trs));
-                        return trs;
-                    public static TraceSource TraceSource { get { return _traceSource.Value; } }
             #if NETFX_TRACE_BUG
                     readonly static AsyncLocal<object> m_currentOperation = new AsyncLocal<object>();
             #endif
                     /// <summary>
-                    /// Starts the logical operation nested to the current operation nested to the current one.
+                    /// If this property is set then <see cref="Debug(string, object[])"/> will produce output.
+                    /// </summary>
+                    public static bool TraceVerbose {
+                        get {
+                            return TraceSource.Switch.ShouldTrace(TraceEventType.Verbose);
+                        }
+                    }
+                    /// <summary>
+                    /// If this property is set then <see cref="Log(string, object[])"/> will produce output.
                     /// </summary>
-                    public static void StartLogicalOperation() {
+                    public static bool TraceInformation {
-                        Trace.CorrelationManager.StartLogicalOperation();
+                        get {
+                            return TraceSource.Switch.ShouldTrace(TraceEventType.Information);
+                        }
+                    }
+                    /// <summary>
+                    /// If this property is set then <see cref="Warn(string, object[])"/> will produce output.
+                    /// </summary>
+                    public static bool TraceWarnings {
+                        get {
+                            return TraceSource.Switch.ShouldTrace(TraceEventType.Warning);
                         }
+                    }
                     /// <summary>
                     /// Starts the logical operation with the specified name, this name is usefull in logs.
                     /// </summary>
                     /// <param name="name">Name.</param>
             #if NETFX_TRACE_BUG
                     public static void StartLogicalOperation(object name) {
                         m_currentOperation.Value = name;
                         Trace.CorrelationManager.StartLogicalOperation(name);
                     }
+                    /// <summary>
+                    /// Starts the logical operation nested to the current operation nested to the current one.
+                    /// </summary>
+                    public static void StartLogicalOperation() {
+                        m_currentOperation.Value = new object();
+                        Trace.CorrelationManager.StartLogicalOperation();
+                    }
             #else
                     public static void StartLogicalOperation(object name) {
                         Trace.CorrelationManager.StartLogicalOperation(name);
                     }
+                    /// <summary>
+                    /// Starts the logical operation nested to the current operation nested to the current one.
+                    /// </summary>
+                    public static void StartLogicalOperation() {
+                        Trace.CorrelationManager.StartLogicalOperation();
+                    }
             #endif
                     /// <summary>
                     /// Ends the logical operation and restores the previous one.
                     /// </summary>
                     public static void StopLogicalOperation() {
                         Trace.CorrelationManager.StopLogicalOperation();
                     }
                     /// <summary>
                     /// Writes a debug message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     [Conditional("DEBUG")]
                     public static void Debug(string format, params object[] arguments) {
+                        TraceSource.TraceEvent(TraceEventType.Verbose, 0, format, arguments);
                     }
                     /// <summary>
                     /// Writes an informational message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     [Conditional("TRACE")]
                     public static void Log(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Information, 0, format, arguments);
                     }
                     /// <summary>
                     /// Writes a warning message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     public static void Warn(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Warning, 0, format, arguments);
                     }
                     /// <summary>
                     /// Writes a error message.
                     /// </summary>
                     /// <param name="format">Format.</param>
                     /// <param name="arguments">Arguments.</param>
                     public static void Error(string format, params object[] arguments) {
                         TraceSource.TraceEvent(TraceEventType.Error, 0, format, arguments);
                     }
                     public static void Error(Exception err) {
                         TraceSource.TraceData(TraceEventType.Error, 0, err);
                     }
                     /// <summary>
                     /// This method save the current activity, and transfers to the specified activity,
                     /// emits <see cref="TraceEventType.Start"/> and returns a scope of the new
                     /// activity.
                     /// </summary>
                     /// <param name="activityName">The name of the new activity/</param>
                     /// <param name="activityId">The identifier of the activity to which
                     /// the control will be transferred</param>
                     /// <returns>A scope of the new activity, dispose it to transfer
                     /// the control back to the original activity.</returns>
                     public static ActivityScope TransferActivity(string activityName, Guid activityId) {
                         var prev = Trace.CorrelationManager.ActivityId;
                         TraceSource.TraceTransfer(0, "Transfer", activityId);
                         Trace.CorrelationManager.ActivityId = activityId;
                         TraceSource.TraceEvent(TraceEventType.Start, 0, activityName);
                         return new ActivityScope(TraceSource, prev, 0, activityName);
                     }
                     /// <summary>
                     /// Emits <see cref="TraceEventType.Start"/> and returns a scope of the
                     /// activity.
                     /// </summary>
                     /// <param name="activityName">The name of the activity to start</param>
                     /// <returns>A scope of the new activity, dispose it to emit
                     /// <see cref="TraceEventType.Stop"/> for the current activity.</returns>
                     public static ActivityScope StartActivity(string activityName) {
                         if (Trace.CorrelationManager.ActivityId == Guid.Empty)
                             Trace.CorrelationManager.ActivityId = Guid.NewGuid();
                         var prev = Trace.CorrelationManager.ActivityId;
                         TraceSource.TraceEvent(TraceEventType.Start, 0, activityName);
                         return new ActivityScope(TraceSource, prev, 0, activityName);
                     }
                     /// <summary>
                     /// Creates new <see cref="LogicalOperation(string)"/> and calls
                     /// to <see cref="CorrelationManager.StartLogicalOperation(object)"/>
                     /// passing the created operation as identity. Calls
                     /// <see cref="TraceSource.TraceData(TraceEventType, int, object)"/>
                     /// to notify listeners on operation start.
                     /// </summary>
                     /// <param name="name">The name of the logical operation.</param>
                     /// <returns>Logical operation scope, disposing it will stop
                     /// logical operation and notify trace listeners.</returns>
                     public static LogicalOperationScope LogicalOperation(string name) {
                         var operation = new LogicalOperation(name);
                         TraceSource.TraceData(TraceEventType.Information, TraceEventCodes.StartLogicalOperation, operation);
                         StartLogicalOperation(operation);
                         return new LogicalOperationScope(TraceSource, operation);
                     }
                 }
             }

Implab/Diagnostics/TraceSourceAttribute.cs +1 0

             using System;
             namespace Implab.Diagnostics {
                 /// <summary>
                 /// Used to mark class which uses <see cref="Trace{T}"/> class to trace it's events
                 /// </summary>
                 [AttributeUsage(AttributeTargets.Class)]
+                [Obsolete("Use TraceRegistry to monitor trace sources")]
                 public class TraceSourceAttribute : Attribute {
                 }
             }

General Comments 3

sergey

|

Auto status change to "Under Review"

sergey

|

ok, latest stable version should be in default

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages