// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.IO;
|
using OpenTap.Diagnostic;
|
using System.Threading;
|
using System.Collections.Generic;
|
using System.Text;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// TraceListener to be used in the App.Config file of the executable to write trace/log data to
|
/// a file.
|
/// </summary>
|
sealed class FileTraceListener : TextWriterTraceListener
|
{
|
string _fileName;
|
|
/// <summary>
|
/// If the log should be written with absolute or relative time.
|
/// </summary>
|
public bool IsRelative { get; set; }
|
|
/// <summary> The current file name of the trace file. </summary>
|
public string FileName => _fileName;
|
/// <summary>
|
/// Initializes a new instance of the FileTraceListener class.
|
/// </summary>
|
/// <param name="fileName">Name of the file to write to.</param>
|
public FileTraceListener(string fileName)
|
: base(fileName)
|
{
|
_fileName = Path.GetFullPath(fileName);
|
|
}
|
|
public event EventHandler FileSizeLimitReached;
|
|
/// <summary> Installs a file limit. When the limit is reached FileSIzeLimitReached is invoked. </summary>
|
public ulong FileSizeLimit = ulong.MaxValue;
|
|
/// <summary>
|
/// Initializes a new instance of the <see cref="OpenTap.FileTraceListener"/>
|
/// class, using the stream as the recipient of the debugging and tracing output.
|
/// </summary>
|
/// <param name="stream">A System.IO.Stream that represents the stream the System.Diagnostics.TextWriterTraceListener writes to.</param>
|
public FileTraceListener(Stream stream) : base(stream)
|
{
|
}
|
|
/// <summary>
|
/// Changes the target file name of the file trace listener. Depending on arguments it might leave the old file as it is
|
/// or move the content to the new file.
|
/// </summary>
|
/// <param name="fileName">The file name of the target file.</param>
|
/// <param name="noExclusiveWriteLock">Allow multiple processes to modify the file.</param>
|
/// <param name="startNewLog">Whether to move the content or to start a new log file.</param>
|
internal void ChangeFileName(string fileName, bool noExclusiveWriteLock, bool startNewLog = false)
|
{
|
string dir = Path.GetDirectoryName(fileName);
|
if (string.IsNullOrWhiteSpace(dir) == false)
|
Directory.CreateDirectory(Path.GetDirectoryName(fileName));
|
|
StreamWriter newwriter = null;
|
if (noExclusiveWriteLock)
|
{
|
// Initialize a stream where the underlying file can be deleted. If the file is deleted, writes just go into the void.
|
var stream = new FileStream(fileName, FileMode.Append, FileAccess.Write, FileShare.Read | FileShare.Delete);
|
newwriter = new StreamWriter(stream, Encoding.UTF8)
|
{
|
AutoFlush = true
|
};
|
}
|
else
|
{
|
newwriter = new StreamWriter(fileName, true, System.Text.Encoding.UTF8)
|
{
|
AutoFlush = true
|
};
|
}
|
|
var OldWriter = base.Writer;
|
base.Writer = newwriter;
|
|
OldWriter.Close();
|
|
if (!startNewLog && _fileName != null)
|
{
|
Writer.Write(File.ReadAllText(_fileName));
|
File.Delete(_fileName);
|
}
|
|
_fileName = Path.GetFullPath(fileName);
|
}
|
|
long first_timestamp = -1;
|
static readonly ThreadLocal<System.Text.StringBuilder> _sb = new ThreadLocal<System.Text.StringBuilder>(() => new System.Text.StringBuilder());
|
readonly object fileTraceLock = new object();
|
public override void TraceEvents(IEnumerable<Event> events)
|
{
|
// Note, this function is heavily optimized.
|
// profile carefully after doing any changes!!
|
|
if (events == null)
|
throw new ArgumentNullException(nameof(events));
|
|
System.Text.StringBuilder sb = _sb.Value;
|
|
sb.Clear();
|
long lastTick = 0;
|
string tickmsg = "";
|
foreach (var evt in events)
|
{
|
if (first_timestamp == -1)
|
first_timestamp = evt.Timestamp;
|
|
if (lastTick != evt.Timestamp)
|
{ // lastTick is to ms resolution
|
// If its the same, dont waste time generating a new string.
|
if (IsRelative)
|
{
|
var elapsed = TimeSpan.FromTicks(evt.Timestamp - first_timestamp);
|
tickmsg = elapsed.ToString("hh\\:mm\\:ss\\.ffffff");
|
}
|
else
|
{
|
var time = new DateTime(evt.Timestamp);
|
tickmsg = time.ToString("yyyy-MM-dd HH:mm:ss.ffffff");
|
}
|
lastTick = evt.Timestamp;
|
}
|
|
sb.Append(tickmsg);
|
sb.Append(" ; ");
|
sb.Append(evt.Source);
|
int paddingcount = 14 - evt.Source.Length;
|
if (paddingcount > 0)
|
sb.Append(' ', paddingcount);
|
|
sb.Append(" ; ");
|
switch ((LogEventType)evt.EventType)
|
{ // All these should have same padding, but dont calculate runtime.
|
case LogEventType.Debug:
|
sb.Append("Debug ");
|
break;
|
case LogEventType.Information:
|
sb.Append("Information");
|
break;
|
case LogEventType.Warning:
|
sb.Append("Warning ");
|
break;
|
case LogEventType.Error:
|
sb.Append("Error ");
|
break;
|
}
|
|
sb.Append(" ; ");
|
if (evt.Message != null)
|
{
|
sb.Append(evt.Message.Replace("\n", "").Replace("\r", ""));
|
}
|
sb.AppendLine();
|
}
|
var logStr = sb.ToString();
|
lock (fileTraceLock)
|
{
|
this.Write(logStr);
|
|
if (Writer is StreamWriter streamWriter && (ulong)streamWriter.BaseStream.Length > FileSizeLimit)
|
{
|
if (FileSizeLimitReached != null)
|
FileSizeLimitReached(this, new EventArgs());
|
}
|
}
|
}
|
}
|
}
|
