/// <inheritdoc/>
public bool ShouldTrace(PlatformTraceLevel traceLevel)
{
if (this.DoNotInitialize)
{
return(false);
}
switch (traceLevel)
{
case PlatformTraceLevel.Off:
return(false);
case PlatformTraceLevel.Error:
return(Source.Switch.ShouldTrace(TraceEventType.Error));
case PlatformTraceLevel.Warning:
return(Source.Switch.ShouldTrace(TraceEventType.Warning));
case PlatformTraceLevel.Info:
return(Source.Switch.ShouldTrace(TraceEventType.Information));
case PlatformTraceLevel.Verbose:
return(Source.Switch.ShouldTrace(TraceEventType.Verbose));
default:
Debug.Fail("Should never get here!");
return(false);
}
}
private static void WriteAtLevel(PlatformTraceLevel level, string message)
{
switch (level)
{
case PlatformTraceLevel.Off:
return;
case PlatformTraceLevel.Error:
Error(message);
break;
case PlatformTraceLevel.Warning:
Warning(message);
break;
case PlatformTraceLevel.Info:
Info(message);
break;
case PlatformTraceLevel.Verbose:
Verbose(message);
break;
default:
Debug.Fail("We should never get here!");
break;
}
}
/// <inheritdoc/>
public void WriteLine(PlatformTraceLevel level, string message)
{
Debug.Assert(message != null, "message != null");
Debug.Assert(!string.IsNullOrEmpty(ProcessName), "!string.IsNullOrEmpty(ProcessName)");
if (EnsureTraceIsInitialized())
{
// The format below is a CSV so that Excel could be used easily to
// view/filter the logs.
var log = string.Format(
CultureInfo.InvariantCulture,
"{0}, {1}, {2:yyyy}/{2:MM}/{2:dd}, {2:HH}:{2:mm}:{2:ss}.{2:fff}, {5}, {3}, {4}",
ProcessId,
Thread.CurrentThread.ManagedThreadId,
DateTime.Now,
ProcessName,
message,
Stopwatch.GetTimestamp());
try
{
Source.TraceEvent(TraceLevelEventTypeMap[this.MapPlatformTraceToTrace(level)], 0, log);
Source.Flush();
}
catch (Exception e)
{
// valid suppress
// Log exception from tracing into event viewer.
LogIgnoredException(e);
}
}
}
/// <inheritdoc/>
public bool InitializeVerboseTrace(string customLogFile)
{
LogFile = Path.GetTempPath() + Path.GetFileNameWithoutExtension(customLogFile).Replace(" ", "_") + ".TpTrace.log";
TraceLevel = PlatformTraceLevel.Verbose;
return(this.TraceInitialized());
}
/// <inheritdoc/>
public void WriteLine(PlatformTraceLevel level, string message)
{
if (this.TraceInitialized() && TraceLevel > PlatformTraceLevel.Off)
{
switch (level)
{
case PlatformTraceLevel.Off:
break;
case PlatformTraceLevel.Error:
UnitTestEventSource.Log.Error(message);
break;
case PlatformTraceLevel.Warning:
UnitTestEventSource.Log.Warn(message);
break;
case PlatformTraceLevel.Info:
UnitTestEventSource.Log.Info(message);
break;
case PlatformTraceLevel.Verbose:
UnitTestEventSource.Log.Verbose(message);
break;
}
}
}
public bool ShouldTrace(PlatformTraceLevel traceLevel)
{
if (this.DoNotInitialize)
{
return(false);
}
return((int)this.traceLevel >= (int)traceLevel);
}
/// <summary>
/// Initializes the tracing with custom log file and trace level.
/// Overrides if any trace is set before.
/// </summary>
/// <param name="customLogFile">Custom log file for trace messages.</param>
/// <param name="traceLevel">Trace level.</param>
/// <returns>Trace initialized flag.</returns>
public static bool InitializeTrace(string customLogFile, PlatformTraceLevel traceLevel)
{
if (!traceImpl.InitializeTrace(customLogFile, traceLevel))
{
ErrorOnInitialization = PlatformEqtTrace.ErrorOnInitialization;
return(false);
}
return(true);
}
public static void VerboseUnlessAlterTrace(bool condition, PlatformTraceLevel level, string format, params object[] args)
{
if (condition)
{
WriteAtLevel(level, format, args);
}
else
{
Verbose(format, args);
}
}
/// <inheritdoc/>
public bool InitializeTrace(string customLogFile, PlatformTraceLevel platformTraceLevel)
{
isInitialized = false;
LogFile = customLogFile;
TraceLevel = this.MapPlatformTraceToTrace(platformTraceLevel);
Source.Switch.Level = TraceSourceLevelsMap[TraceLevel];
// Ensure trace is initialized
return(EnsureTraceIsInitialized());
}
public void WriteLine(PlatformTraceLevel traceLevel, string message)
{
if (!this.ShouldTrace(traceLevel))
{
return;
}
var level = Enum.GetName(typeof(PlatformTraceLevel), traceLevel);
Debug.WriteLine($"[{level}] {message}");
}
public static void VerboseUnlessAlterTrace(bool condition, PlatformTraceLevel level, string message)
{
if (condition)
{
WriteAtLevel(level, message);
}
else
{
Verbose(message);
}
}
public static void InfoUnlessAlterTrace(bool condition, PlatformTraceLevel bumpLevel, string message)
{
if (condition)
{
WriteAtLevel(bumpLevel, message);
}
else
{
Info(message);
}
}
public static void InfoUnlessAlterTrace(bool condition, PlatformTraceLevel bumpLevel, string format, params object[] args)
{
if (condition)
{
WriteAtLevel(bumpLevel, format, args);
}
else
{
Info(format, args);
}
}
/// <summary>
/// Initializes Tracing based on Trace Level
/// </summary>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private bool TraceInitialized()
{
lock (initLock)
{
if (isInitialized)
{
return(isInitialized);
}
try
{
var eventListener = new FileEventListener(string.IsNullOrEmpty(LogFile) ? "UnitTestLog" : LogFile);
PlatformTraceLevel traceLevel = this.GetTraceLevel();
if (traceLevel > PlatformTraceLevel.Off)
{
eventListener.EnableEvents(UnitTestEventSource.Log, EventLevel.Error);
}
if (traceLevel > PlatformTraceLevel.Error)
{
eventListener.EnableEvents(UnitTestEventSource.Log, EventLevel.Warning);
}
if (traceLevel > PlatformTraceLevel.Warning)
{
eventListener.EnableEvents(UnitTestEventSource.Log, EventLevel.Informational);
}
if (traceLevel > PlatformTraceLevel.Info)
{
eventListener.EnableEvents(UnitTestEventSource.Log, EventLevel.Verbose);
}
isInitialized = true;
}
catch (Exception ex)
{
this.UnInitializeVerboseTrace();
ErrorOnInitialization = ex.Message;
return(false);
}
return(isInitialized);
}
}
/// <inheritdoc/>
public bool InitializeVerboseTrace(string customLogFile)
{
string logFileName = string.Empty;
try
{
logFileName = Path.GetFileNameWithoutExtension(customLogFile.TrimStart('"').TrimEnd('"')).Replace(" ", "_");
}
catch
{
logFileName = Guid.NewGuid().ToString();
}
LogFile = Path.Combine(Path.GetTempPath(), logFileName + ".TpTrace.log");
TraceLevel = PlatformTraceLevel.Verbose;
return(this.TraceInitialized());
}
public TraceLevel MapPlatformTraceToTrace(PlatformTraceLevel traceLevel)
{
switch (traceLevel)
{
case PlatformTraceLevel.Off:
return(TraceLevel.Off);
case PlatformTraceLevel.Error:
return(TraceLevel.Error);
case PlatformTraceLevel.Warning:
return(TraceLevel.Warning);
case PlatformTraceLevel.Info:
return(TraceLevel.Info);
case PlatformTraceLevel.Verbose:
return(TraceLevel.Verbose);
default:
Debug.Fail("Should never get here!");
return(TraceLevel.Verbose);
}
}
private void UnInitializeVerboseTrace()
{
isInitialized = false;
LogFile = null;
TraceLevel = PlatformTraceLevel.Off;
}
/// <inheritdoc/>
public void SetTraceLevel(PlatformTraceLevel value)
{
Source.Switch.Level = TraceSourceLevelsMap[this.MapPlatformTraceToTrace(value)];
}
public void WriteLine(PlatformTraceLevel level, string message)
{
}
public bool ShouldTrace(PlatformTraceLevel traceLevel)
{
return(false);
}
public void SetTraceLevel(PlatformTraceLevel value)
{
throw new NotImplementedException();
}
public bool ShouldTrace(PlatformTraceLevel traceLevel)
{
throw new NotImplementedException();
}
public bool InitializeTrace(string customLogFile, PlatformTraceLevel traceLevel)
{
this.traceLevel = traceLevel;
return(false);
}
/// <inheritdoc/>
public void SetTraceLevel(PlatformTraceLevel value)
{
TraceLevel = value;
}
/// <inheritdoc/>
public bool ShouldTrace(PlatformTraceLevel traceLevel)
{
return(isInitialized);
}
private static void WriteAtLevel(PlatformTraceLevel level, string format, params object[] args)
{
Debug.Assert(format != null, "format != null");
WriteAtLevel(level, string.Format(CultureInfo.InvariantCulture, format, args));
}
public void WriteLine(PlatformTraceLevel level, string message)
{
throw new NotImplementedException();
}