/// <summary>
/// Logs the entry.
/// </summary>
/// <param name="entry">The entry.</param>
/// <param name="clientAddress">The client address.</param>
private void LogEntry(LogEntryMessage entry, string clientAddress)
{
switch (entry.Severity)
{
case TraceEventType.Critical:
logger.Fatal(() => this.FormatMessage(entry.Message, clientAddress));
break;
case TraceEventType.Error:
logger.Error(() => this.FormatMessage(entry.Message, clientAddress));
break;
case TraceEventType.Warning:
logger.Warn(() => this.FormatMessage(entry.Message, clientAddress));
break;
case TraceEventType.Information:
logger.Info(() => this.FormatMessage(entry.Message, clientAddress));
break;
case TraceEventType.Verbose:
logger.Debug(() => this.FormatMessage(entry.Message, clientAddress));
break;
}
}
/// <summary>
/// Parses Log Entries from the collection of log nodes.
/// </summary>
/// <param name="nodes">The collection of Xml nodes which are valid LogEntry nodes.</param>
/// <param name="result">The TestResult which will host the parsed LogEntries.</param>
private static void ParseTestCaseLogEntries(XmlNodeList nodes, TestResult result)
{
foreach (XmlNode child in nodes)
{
if (child.NodeType == XmlNodeType.Element)
{
LogEntry entry = null;
switch (child.Name)
{
case Xml.Info: entry = new LogEntryInfo(child.InnerText); break;
case Xml.Message: entry = new LogEntryMessage(child.InnerText); break;
case Xml.Warning: entry = new LogEntryWarning(child.InnerText); break;
case Xml.Error: entry = ParseTestCaseLogError(child); break;
case Xml.FatalError: entry = new LogEntryFatalError(child.InnerText); break;
case Xml.Exception: entry = ParseTestCaseLogException(child); break;
}
if (entry != null)
{
entry.Source = ParseSourceInfo(child);
result.LogEntries.Add(entry);
}
}
}
}
/// <summary>
/// Overridden to redirect to call <see cref="Log"/>.
/// </summary>
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
if ((this.Filter == null) || this.Filter.ShouldTrace(eventCache, source, eventType, id, null, null, data, null))
{
if (data is LogEntry)
{
data = new LogEntryMessage(base.Formatter, (LogEntry)data);
}
Log(eventType, source, id, "{0}", data);
}
}
public static TextWriter WriteJson(TextWriter writer, LogEntryMessage message)
{
return(writer
.WriteJsonStartObject()
.WriteJsonProperty("level", message.Level).WriteJsonComma()
.WriteJsonProperty("message", message.Message).WriteJsonComma()
.WriteJsonProperty("stacktrace", message.Stacktrace).WriteJsonComma()
.WriteJsonProperty("traceId", message.TraceId).WriteJsonComma()
.WriteJsonProperty("attachments", message.Attachments, WriteJson)
.WriteJsonEndObject());
}
private static void Main(string[] args)
{
var jobId = 1;
ColorConsole.WriteLineGray("Creating Client Actor System");
var serverLocation = ConfigurationManager.AppSettings["serverLocation"];
var actorSystem = ActorSystem.Create("ConsoleClient");
ColorConsole.WriteLineGray("Creating actor supervisory hierarchy");
var logger = actorSystem.ActorSelection($"akka.tcp://{ serverLocation }/user/LogCoordinator");
var reporter = actorSystem.ActorSelection($"akka.tcp://{ serverLocation }/user/Report");
string command;
do
{
ShortPause();
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.DarkGray;
ColorConsole.WriteLineGray("enter a command and hit enter");
command = Console.ReadLine() ?? string.Empty;
if (command.StartsWith("log"))
{
var appId = command.Split(',')[1];
var logMsg = command.Split(',')[2];
var message = new LogEntryMessage(appId, LogEventType.Info, logMsg);
logger.Tell(message);
}
if (command.StartsWith("rpt"))
{
var report = new ReportMessage(jobId++, command.Split(',')[1]);
Task.Run(async() =>
{
var r = reporter.Ask(report);
var ack = await r;
ColorConsole.WriteLineCyan(ack.ToString());
ColorConsole.WriteLineGray("");
});
}
} while (command != "exit");
actorSystem.Terminate();
actorSystem.WhenTerminated.Wait();
ColorConsole.WriteLineGray("Actor system terminated");
Console.ReadKey();
Environment.Exit(1);
}
private static Dictionary <string, string> GetRaygunErrorMessageData(LogEntryMessage message)
{
var data = new Dictionary <string, string>
{
{ "level", Convert.ToString(message.Level) }
};
if (message.Attachments != null && message.Attachments.Any())
{
data.Add("attachmentIds", string.Join(",", message.Attachments.Select(a => a.Id)));
}
if (!string.IsNullOrEmpty(message.TraceId))
{
data.Add("traceId", message.TraceId);
}
return(data);
}
/// <summary>
/// Translates the incoming <see cref="LogEntryMessage"/> into a <see cref="LogEntry"/>.
/// </summary>
/// <param name="entry">
/// The log entry coming from the client.
/// </param>
/// <returns>
/// A <see cref="LogEntry"/> instance that can be stored in the log.
/// </returns>
protected override LogEntry Translate(LogEntryMessage entry)
{
var logEntry = entry.ToLogEntry();
if (logEntry.MachineName == null)
{
logEntry.MachineName = string.Empty;
}
if (logEntry.ProcessId == null)
{
logEntry.ProcessId = string.Empty;
}
if (logEntry.ProcessName == null)
{
logEntry.ProcessName = string.Empty;
}
return(logEntry);
}
private RaygunErrorMessage GetRaygunError(LogEntry logEntry)
{
var messages = logEntry.Messages.Where(m => m.Level >= _minLevel).ToArray();
if (messages.Length == 0)
{
// If this happens, RabbitMQ binding and config MIN_LEVEL differs -> use message with highest severity
LogEntryMessage message = messages.MaxBy(m => m.Level);
return(new RaygunErrorMessage
{
Message = $"{logEntry.ServiceId} {message.Message}",
StackTrace = CreateStackTrace(message.Stacktrace),
Data = GetRaygunErrorMessageData(message)
});
}
if (messages.Length == 1)
{
var message = messages.Single();
return(new RaygunErrorMessage
{
Message = $"{logEntry.ServiceId} {message.Message}",
StackTrace = CreateStackTrace(message.Stacktrace),
Data = GetRaygunErrorMessageData(message)
});
}
var highestSeverityMessage = messages.MaxBy(m => m.Level);
return(new RaygunErrorMessage
{
InnerErrors = messages.Select(m => new RaygunErrorMessage
{
Message = m.Message,
StackTrace = CreateStackTrace(m.Stacktrace),
Data = GetRaygunErrorMessageData(m)
}).ToArray(),
Message = $"{logEntry.ServiceId} {highestSeverityMessage.Message}"
});
}
/// <summary>
/// Overridden to redirect to call <see cref="Log"/>.
/// </summary>
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
if ((this.Filter == null) || this.Filter.ShouldTrace(eventCache, source, eventType, id, null, null, data, null))
{
if (data is LogEntry)
{
data = new LogEntryMessage(base.Formatter, (LogEntry)data);
}
Log(eventType, source, id, "{0}", data);
}
}
private void LogButton_Click(object sender, RoutedEventArgs e)
{
var message = new LogEntryMessage("UI-Client", LogEventType.Info, LogMessage.Text);
_api.Tell(message);
}
private void HandleLogEntryMessage(LogEntryMessage msg)
{
var logEntryActor = GetLogEntryActor(msg.AppId);
logEntryActor.Tell(msg);
}
private void HandleLogEntryMessage(LogEntryMessage msg)
{
File.AppendAllText(_logFileName, $"{ msg }\r\n");
ColorConsole.WriteLineYellow($"Message logged for LoggerActor '{ msg.AppId }'.");
}
