|
|
// 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"/> and uses
|
|
|
/// it to perform logging operations.
|
|
|
/// </summary>
|
|
|
/// <typeparam name="T">The type for which tracing is demanded.</typeparam>
|
|
|
public static class Trace<T> {
|
|
|
|
|
|
readonly static Lazy<TraceSource> _trace = new Lazy<TraceSource>(() => TraceSourceChannel<T>.Default.Source);
|
|
|
|
|
|
/// <summary>
|
|
|
/// The <see cref="TraceSource"/> associated with the current class.
|
|
|
/// TraceSource is created using <see cref="TraceSourceChannel{T}"/>.
|
|
|
/// </summary>
|
|
|
public static TraceSource TraceSource { get { return _trace.Value; } }
|
|
|
|
|
|
#if NETFX_TRACE_BUG
|
|
|
// AsyncLocal will store value inside the current execution context
|
|
|
// and will force it to be copied... not a very effective solution.
|
|
|
readonly static AsyncLocal<object> m_currentOperation = new AsyncLocal<object>();
|
|
|
#endif
|
|
|
|
|
|
/// <summary>
|
|
|
/// 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 bool TraceInformation {
|
|
|
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);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
