Mercurial > pub > ImplabNet
annotate Implab/Diagnostics/Trace.cs @ 280:f07be402ab02 v3
Added Trace<T>.Debug(...) method for debug messages
Added ContainerBuilde.LoadConfig(Uri) method
| author | cin |
|---|---|
| date | Fri, 25 May 2018 19:15:26 +0300 |
| parents | b00441e04738 |
| children | e0916ddc9950 |
| rev | line source |
|---|---|
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
1 using System; |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
2 using System.Collections.Generic; |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
3 using System.Diagnostics; |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
4 using System.Linq; |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
5 using System.Text; |
|
255
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
6 using System.Threading; |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
7 using System.Threading.Tasks; |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
8 |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
9 namespace Implab.Diagnostics { |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
10 public static class Trace<T> { |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
11 |
|
255
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
12 public static TraceSource TraceSource { get; } = new TraceSource(typeof(T).Name); |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
13 |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
14 #if NETFX_TRACE_BUG |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
15 readonly static AsyncLocal<object> m_currentOperation = new AsyncLocal<object>(); |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
16 #endif |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
17 |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
18 /// <summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
19 /// Starts the logical operation nested to the current operation nested to the current one. |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
20 /// </summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
21 public static void StartLogicalOperation() { |
| 252 | 22 Trace.CorrelationManager.StartLogicalOperation(); |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
23 |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
24 } |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
25 |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
26 /// <summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
27 /// Starts the logical operation with the specified name, this name is usefull in logs. |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
28 /// </summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
29 /// <param name="name">Name.</param> |
|
255
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
30 #if NETFX_TRACE_BUG |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
31 public static void StartLogicalOperation(object name) { |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
32 m_currentOperation.Value = name; |
| 253 | 33 Trace.CorrelationManager.StartLogicalOperation(name); |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
34 } |
|
255
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
35 #else |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
36 public static void StartLogicalOperation(object name) { |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
37 Trace.CorrelationManager.StartLogicalOperation(name); |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
38 } |
|
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
39 #endif |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
40 |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
41 /// <summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
42 /// Ends the logical operation and restores the previous one. |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
43 /// </summary> |
| 252 | 44 public static void StopLogicalOperation() { |
| 45 Trace.CorrelationManager.StopLogicalOperation(); | |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
46 } |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
47 |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
48 /// <summary> |
| 280 | 49 /// Writes a debug message. |
| 50 /// </summary> | |
| 51 /// <param name="format">Format.</param> | |
| 52 /// <param name="arguments">Arguments.</param> | |
| 53 [Conditional("DEBUG")] | |
| 54 public static void Debug(string format, params object[] arguments) { | |
| 55 | |
| 56 } | |
| 57 | |
| 58 /// <summary> | |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
59 /// Writes an informational message. |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
60 /// </summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
61 /// <param name="format">Format.</param> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
62 /// <param name="arguments">Arguments.</param> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
63 [Conditional("TRACE")] |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
64 public static void Log(string format, params object[] arguments) { |
| 253 | 65 TraceSource.TraceEvent(TraceEventType.Information, 0, format, arguments); |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
66 } |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
67 |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
68 /// <summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
69 /// Writes a warning message. |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
70 /// </summary> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
71 /// <param name="format">Format.</param> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
72 /// <param name="arguments">Arguments.</param> |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
73 public static void Warn(string format, params object[] arguments) { |
| 253 | 74 TraceSource.TraceEvent(TraceEventType.Warning, 0, format, arguments); |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
75 } |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
76 |
| 280 | 77 /// <summary> |
| 78 /// Writes a error message. | |
| 79 /// </summary> | |
| 80 /// <param name="format">Format.</param> | |
| 81 /// <param name="arguments">Arguments.</param> | |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
82 public static void Error(string format, params object[] arguments) { |
| 253 | 83 TraceSource.TraceEvent(TraceEventType.Error, 0, format, arguments); |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
84 } |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
85 |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
86 public static void Error(Exception err) { |
| 253 | 87 TraceSource.TraceData(TraceEventType.Error, 0, err); |
| 88 } | |
| 89 | |
| 90 /// <summary> | |
| 91 /// This method save the current activity, and transfers to the specified activity, | |
| 92 /// emits <see cref="TraceEventType.Start"/> and returns a scope of the new | |
| 93 /// activity. | |
| 94 /// </summary> | |
| 95 /// <param name="activityName">The name of the new activity/</param> | |
| 96 /// <param name="activityId">The identifier of the activity to which | |
| 97 /// the control will be transferred</param> | |
| 98 /// <returns>A scope of the new activity, dispose it to transfer | |
| 99 /// the control back to the original activity.</returns> | |
| 100 public static ActivityScope TransferActivity(string activityName, Guid activityId) { | |
| 101 var prev = Trace.CorrelationManager.ActivityId; | |
| 102 | |
| 103 TraceSource.TraceTransfer(0, "Transfer", activityId); | |
| 104 Trace.CorrelationManager.ActivityId = activityId; | |
| 105 TraceSource.TraceEvent(TraceEventType.Start, 0, activityName); | |
| 106 | |
| 107 return new ActivityScope(TraceSource, prev, 0, activityName); | |
| 108 } | |
| 109 | |
| 110 /// <summary> | |
| 111 /// Emits <see cref="TraceEventType.Start"/> and returns a scope of the | |
| 112 /// activity. | |
| 113 /// </summary> | |
| 114 /// <param name="activityName">The name of the activity to start</param> | |
| 115 /// <returns>A scope of the new activity, dispose it to emit | |
| 116 /// <see cref="TraceEventType.Stop"/> for the current activity.</returns> | |
| 117 public static ActivityScope StartActivity(string activityName) { | |
| 118 if (Trace.CorrelationManager.ActivityId == Guid.Empty) | |
| 119 Trace.CorrelationManager.ActivityId = Guid.NewGuid(); | |
| 120 | |
| 121 var prev = Trace.CorrelationManager.ActivityId; | |
| 122 | |
| 123 TraceSource.TraceEvent(TraceEventType.Start, 0, activityName); | |
| 124 return new ActivityScope(TraceSource, prev, 0, activityName); | |
| 125 } | |
| 126 | |
| 127 /// <summary> | |
| 128 /// Creates new <see cref="LogicalOperation(string)"/> and calls | |
| 129 /// to <see cref="CorrelationManager.StartLogicalOperation(object)"/> | |
| 130 /// passing the created operation as identity. Calls | |
| 131 /// <see cref="TraceSource.TraceData(TraceEventType, int, object)"/> | |
| 132 /// to notify listeners on operation start. | |
| 133 /// </summary> | |
| 134 /// <param name="name">The name of the logical operation.</param> | |
| 135 /// <returns>Logical operation scope, disposing it will stop | |
| 136 /// logical operation and notify trace listeners.</returns> | |
| 137 public static LogicalOperationScope LogicalOperation(string name) { | |
| 138 var operation = new LogicalOperation(name); | |
| 139 TraceSource.TraceData(TraceEventType.Information, TraceEventCodes.StartLogicalOperation, operation); | |
|
255
b00441e04738
Adde workaround to the behaviour of the logical operations stack in conjuction
cin
parents:
253
diff
changeset
|
140 StartLogicalOperation(operation); |
| 253 | 141 return new LogicalOperationScope(TraceSource, operation); |
|
212
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
142 } |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
143 } |
|
a01d9df88d74
Added class Trace<T> to manage channels for individual classes, if SomeClass
cin
parents:
diff
changeset
|
144 } |
