static void OnLogger(MyEvent args)
{
LoggerEvent evt = args as LoggerEvent;
string message = string.Concat(new object[] { "[UnityNet - ", LoggerEvent.LogEventType(evt.LogLevel), "] ", evt.ErrorDes });
Console.WriteLine(message);
}
/// <inheritdoc/>
public void Log(object sender, LoggerEvent loggerEvent, string format, params object[] args)
{
if (loggerEvent == LoggerEvent.Error && ctor != null)
{
throw (Exception)ctor.Invoke(new object[] { string.Format(format, args) });
}
}
public static void Log(this ILogger logger, TraceEventType eventType,
EventProperties properties)
{
if (properties.ContainsKey(LoggerEvent.PARAMETERS_PROPERTY))
{
if (properties[LoggerEvent.PARAMETERS_PROPERTY] == null ||
((object[])properties[LoggerEvent.PARAMETERS_PROPERTY]).Length <= 0)
{
properties.Remove(LoggerEvent.PARAMETERS_PROPERTY);
}
}
var loggerEvent = new LoggerEvent {
EventType = eventType
};
foreach (var property in properties)
{
loggerEvent[property.Key] = property.Value;
}
#if DEBUG
if (!loggerEvent.Properties.ContainsKey(LoggerEvent.METHODNAME_PROPERTY))
{
loggerEvent[LoggerEvent.METHODNAME_PROPERTY] = GetCallerMethodName(typeof(LoggerExtensions));
}
#endif
logger.Log(loggerEvent);
}
public override void Write(ParsedLayout layout, TextWriter tw, LoggerEvent evt)
{
PropertyTree data = this.GetDataTree(evt);
IEnumerable <PropertyNode> nodes;
if (string.IsNullOrWhiteSpace(this.Property))
{
nodes = new [] { data };
}
else
{
nodes = ApplyDataFilter(data);
}
foreach (var node in nodes)
{
if (node.IsPropertyTree)
{
WriteNode((PropertyTree)node, layout, this.Property, tw, 0);
}
else
{
WriteCore(layout, node.Value, Property, tw);
}
}
}
public bool Accepted(EventWriterTriplet writerTriplet, LoggerEvent loggerEvent, string message)
{
var newMessage = loggerEvent.Properties[LoggerEvent.MESSAGE_PROPERTY].ToString();
bool asseptResult = false;
if (!loggerEvent.Properties.ContainsKey(BpcLoggerExtensions.MESSAGEID_PROPERTY))
{
asseptResult = true;
}
else if (!_filteredTypes.Contains((Message)loggerEvent.Properties[BpcLoggerExtensions.MESSAGEID_PROPERTY]))
{
asseptResult = true;
}
else if (writerTriplet.Raw)
{
newMessage = string.Format(newMessage, (object[])loggerEvent[LoggerEvent.PARAMETERS_PROPERTY]);
asseptResult = _lastMessageText != newMessage;
}
else if (!writerTriplet.Raw && _lastMessageText != newMessage)
{
asseptResult = true;
}
_lastMessageText = newMessage;
return(asseptResult);
}
public override void Write(LoggerEvent loggerEvent)
{
UpdateColors(loggerEvent.Level);
pattern.WriteBody(console.Out, loggerEvent);
console.ResetColor();
}
public string Expand(LoggerEvent evt)
{
StringWriter sw = new StringWriter();
WriteBody(sw, evt);
return(sw.ToString());
}
public void WriteBody(TextWriter writer, LoggerEvent evt)
{
foreach (Expr e in this.expressions)
{
e.Write(this, writer, evt);
}
}
public void Log(object sender, LoggerEvent loggerEvent, string format, params object[] args)
{
ConsoleColor oldColor;
oldColor = Console.ForegroundColor;
switch (loggerEvent)
{
case LoggerEvent.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LoggerEvent.Warning:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
case LoggerEvent.Info:
Console.ForegroundColor = ConsoleColor.Gray;
break;
case LoggerEvent.Verbose:
case LoggerEvent.VeryVerbose:
Console.ForegroundColor = ConsoleColor.DarkGray;
break;
default:
throw new ArgumentOutOfRangeException(nameof(loggerEvent));
}
Console.WriteLine("LoggerEvent: " + loggerEvent.ToString());
Console.WriteLine("Info: " + Environment.NewLine + string.Format(format, args));
Console.WriteLine();
Console.ForegroundColor = oldColor;
}
public override void Write(LoggerEvent loggerEvent)
{
foreach (var item in _all)
{
item.Write(loggerEvent);
}
}
protected override string ConstructMessage(LoggerEvent logEvent)
{
var recResultMsg = ApplyLogEventParams(logEvent);
recResultMsg = String.Format(LOG_MESSAGE_FORMAT, GetTimeLabel(), recResultMsg);
return(recResultMsg);
}
static void PrintMethod(MethodPrinter methodPrinter, MethodDef method)
{
const LoggerEvent dumpLogLevel = LoggerEvent.Verbose;
if (Logger.Instance.IgnoresEvent(dumpLogLevel))
{
return;
}
Logger.Instance.Indent();
Logger.v("Locals:");
Logger.Instance.Indent();
for (int i = 0; i < method.Body.Variables.Count; i++)
{
Logger.v("#{0}: {1}", i, method.Body.Variables[i].Type);
}
Logger.Instance.DeIndent();
Logger.v("Code:");
Logger.Instance.Indent();
methodPrinter.Print(dumpLogLevel, method.Body.Instructions, method.Body.ExceptionHandlers);
Logger.Instance.DeIndent();
Logger.Instance.DeIndent();
}
private void InfectionDemon()
{
while (!IsDayOver)
{
Thread.Sleep(MagicTiming);
var previous = new Patient();
previous.IsInfected = false;
var keys = _queue.Keys.ToArray();
for (var i = 0; i < keys.Length; i++)
{
try
{
if (!_queue[keys[i]].IsInfected)
{
continue;
}
if (i > 0)
{
_queue[keys[i - 1]].IsInfected = true;
LoggerEvent?.Invoke($"Infecting in queue patient {keys[i - 1]}\n");
}
if (i < keys.Length - 1)
{
_queue[keys[i + 1]].IsInfected = true;
LoggerEvent?.Invoke($"Infecting in queue patient {keys[i + 1]}\n");
}
i++;
}
catch (KeyNotFoundException)
{
}
}
}
}
public void Log(bool canIgnore, object sender, LoggerEvent loggerEvent, string format, params object[] args)
{
if (IgnoresEvent(loggerEvent))
{
return;
}
if (canIgnore && IgnoreMessage(loggerEvent, format, args))
{
return;
}
switch (loggerEvent)
{
case LoggerEvent.Error:
foreach (var l in string.Format(format, args).Split('\n'))
{
LogMessage(string.Empty, string.Format("ERROR: {0}", l));
}
break;
case LoggerEvent.Warning:
foreach (var l in string.Format(format, args).Split('\n'))
{
LogMessage(string.Empty, string.Format("WARNING: {0}", l));
}
break;
default:
var indent = loggerEvent <= LoggerEvent.Warning ? "" : indentString;
LogMessage(indent, format, args);
break;
}
}
internal static string Body(ParsedLayout pl, LoggerEvent evt)
{
StringWriter sw = new StringWriter();
pl.WriteBody(sw, evt);
return(sw.ToString());
}
/// <inheritdoc/>
public bool IgnoresEvent(LoggerEvent loggerEvent)
{
if (ctor == null)
{
return(true);
}
return(loggerEvent != LoggerEvent.Error);
}
// IEventLogger implementation
public async Task <LoggerEvent> AddEventAsync(LoggerEvent loggerEvent)
{
log.Debug("AddEventAsync: " + loggerEvent);
await this.loggerData.CreateAsync(loggerEvent);
return(loggerEvent);
}
protected override void Capture(LoggerEvent loggerEvent)
{
var evt = loggerEvent as LogLogEvent;
if (evt != null)
{
LogLog.Write(evt.Level, evt.ErrorCode, evt.Message);
}
}
protected override string Evaluate(LoggerEvent evt)
{
if (evt.Level == null)
{
return(string.Empty);
}
return(evt.Level.ToString(this.Format));
}
public override void Render(LoggerEvent loggerEvent)
{
if (loggerEvent == null)
{
throw new ArgumentNullException("loggerEvent");
}
writer.WriteObject(loggerEvent);
}
public string Format(LoggerEvent loggerEvent)
{
var textBuilder = new TextBuilder();
textBuilder
.Line("EventType: " + loggerEvent.EventType);
LoggingUtils.Format(textBuilder, loggerEvent.Properties);
LoggingUtils.AddSeparator(textBuilder);
return textBuilder.ToString();
}
public string Format(LoggerEvent loggerEvent)
{
var textBuilder = new TextBuilder();
textBuilder
.Line("EventType: " + loggerEvent.EventType);
LoggingUtils.Format(textBuilder, loggerEvent.Properties);
LoggingUtils.AddSeparator(textBuilder);
return(textBuilder.ToString());
}
/// <summary>
/// Return IO Path of Location and folder name combination
/// </summary>
/// <param name="FolderName">Folder name</param>
/// <param name="Location">Top level folder.</param>
/// <returns></returns>
public static string BulldDir(string FolderName, string Location)
{
LoggerEventArgs eventArgs = new LoggerEventArgs();
eventArgs.OriginName = name;
eventArgs.LogMessage = "BulldDir";
LoggerEvent?.Invoke(null, eventArgs);
return(System.IO.Path.Combine(Location, FolderName));
}
public void Log(LoggerEvent logEvent)
{
var resultMsg = ConstructMessage(logEvent);
if (CanAppendLine(logEvent, resultMsg))
{
_writer.WriteLine(resultMsg);
_writer.Flush();
}
}
/// <summary>
/// HttpEventCollectorEventInfo c-or.
/// </summary>
/// <param name="id">Event id.</param>
/// <param name="severity">Event severity info.</param>
/// <param name="message">Event message text.</param>
/// <param name="data">Event auxiliary data.</param>
/// <param name="metadata">Logger metadata.</param>
public HttpEventCollectorEventInfo(
string id, string severity, string message, object data,
Metadata metadata)
{
// set timestamp to the current UTC epoch time
double epochTime = (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
Timestamp = epochTime.ToString("#.000"); // truncate to 3 digits after floating point
this.metadata = metadata ?? new Metadata();
Event = new LoggerEvent(id, severity, message, data);
}
protected override string Evaluate(LoggerEvent evt)
{
if (evt.Exception == null)
{
return(string.Empty);
}
else
{
return(evt.Exception.ToString(this.Format));
}
}
public Task CreateAsync(LoggerEvent loggerEvent)
{
log.Debug("CreateAsync: ");
if (this.events.TryAdd(loggerEvent.Id, loggerEvent))
{
this.sortedEvents.TryAdd(loggerEvent.EventTime, loggerEvent);
}
return Task.CompletedTask;
}
protected override string Evaluate(LoggerEvent evt)
{
if (evt.SourceLogger == null || evt.SourceLogger.File == null)
{
return(string.Empty);
}
FileTarget ft = evt.SourceLogger.File;
return(FormatDateTime(ft.IndexTimeStamp));
}
private void NewPatientDemon()
{
while (!IsDayOver)
{
var newId = _queue.Count == 0 ? 0 : _queue.Keys.Max() + 1;
var p = new Patient();
_queue[newId] = p;
LoggerEvent?.Invoke($"New patient IsInfected {p.IsInfected}\n");
Thread.Sleep(rnd.Next(MagicTiming));
}
}
public void log_format_capture_arguments_two_items()
{
MemoryTarget target = new MemoryTarget(null);
Logger l = Logger.Create(target);
l.ErrorFormat("Message: {0}? {1}", new object[] { "Hello", "Is it me you're looking for?" });
LoggerEvent evt = target.Events[0];
Assert.Equal("Message: {0}? {1}", evt.Message);
Assert.Equal("Message: Hello? Is it me you're looking for?", evt.FormatMessage());
}
public void Log(object sender, LoggerEvent loggerEvent, string format, params object[] args)
{
if (!this.IgnoresEvent(loggerEvent))
{
if (sender != null)
Console.WriteLine(String.Format(
"[{0}] {1}", sender.GetType().FullName, String.Format(format, args)
));
else
Console.WriteLine(String.Format(format, args));
}
}
protected override bool CanAppendLine(LoggerEvent logEvent, string message)
{
var fileSystemManager = GetFileSystemManager();
if (fileSystemManager == null)
{
return(true);
}
var requiredSize = message.Length / FileUtils.BYTES_IN_KB + 1;
return(fileSystemManager.ReserveDiskSpace(_logDirectory, requiredSize));
}
void ILogger.Log(object sender, LoggerEvent loggerEvent, string format, params object[] args)
{
ThrowIfCanceled();
if (OnLogMessage != null)
{
var evtType =
loggerEvent == LoggerEvent.Error ? ModuleSaverLogEvent.Error :
loggerEvent == LoggerEvent.Warning ? ModuleSaverLogEvent.Warning :
ModuleSaverLogEvent.Other;
OnLogMessage(this, new ModuleSaverLogEventArgs(string.Format(format, args), evtType));
}
}
public void Print(LoggerEvent loggerEvent, IList<Instruction> allInstructions, IList<ExceptionHandler> allExceptionHandlers) {
try {
this.loggerEvent = loggerEvent;
this.allInstructions = allInstructions;
this.allExceptionHandlers = allExceptionHandlers;
lastExInfo = new ExInfo();
Print();
}
finally {
this.allInstructions = null;
this.allExceptionHandlers = null;
targets.Clear();
labels.Clear();
exInfos.Clear();
lastExInfo = null;
}
}
public static void Log(this ILogger logger, TraceEventType eventType,
EventProperties properties)
{
if (properties.ContainsKey(LoggerEvent.PARAMETERS_PROPERTY))
{
if (properties[LoggerEvent.PARAMETERS_PROPERTY] == null ||
((object[])properties[LoggerEvent.PARAMETERS_PROPERTY]).Length <= 0)
{
properties.Remove(LoggerEvent.PARAMETERS_PROPERTY);
}
}
var loggerEvent = new LoggerEvent { EventType = eventType };
foreach (var property in properties)
{
loggerEvent[property.Key] = property.Value;
}
#if DEBUG
if (!loggerEvent.Properties.ContainsKey(LoggerEvent.METHODNAME_PROPERTY))
{
loggerEvent[LoggerEvent.METHODNAME_PROPERTY] = GetCallerMethodName(typeof(LoggerExtensions));
}
#endif
logger.Log(loggerEvent);
}
/// <inheritdoc/>
public void Log(object sender, LoggerEvent loggerEvent, string format, params object[] args) {
if (loggerEvent == LoggerEvent.Error && ctor != null)
throw (Exception)ctor.Invoke(new object[] { string.Format(format, args) });
}
public ConsoleLogger(LoggerEvent level)
{
this.Level = level;
}
public bool IgnoresEvent(LoggerEvent loggerEvent)
{
return loggerEvent > this.Level;
}
public static void PrintStackTrace(Exception ex, LoggerEvent loggerEvent) {
var line = new string('-', 78);
Logger.Instance.Log(false, null, loggerEvent, "\n\n");
Logger.Instance.Log(false, null, loggerEvent, line);
Logger.Instance.Log(false, null, loggerEvent, "Stack trace:\n{0}", ex.StackTrace);
Logger.Instance.Log(false, null, loggerEvent, "\n\nCaught an exception:\n");
Logger.Instance.Log(false, null, loggerEvent, line);
Logger.Instance.Log(false, null, loggerEvent, "Message:");
Logger.Instance.Log(false, null, loggerEvent, " {0}", ex.Message);
Logger.Instance.Log(false, null, loggerEvent, "Type:");
Logger.Instance.Log(false, null, loggerEvent, " {0}", ex.GetType());
Logger.Instance.Log(false, null, loggerEvent, line);
}
public void Log(object sender, LoggerEvent loggerEvent, string format, params object[] args) {
Log(true, sender, loggerEvent, format, args);
}
public bool IgnoresEvent(LoggerEvent loggerEvent) {
return loggerEvent > maxLoggerEvent;
}
/// <inheritdoc/>
public bool IgnoresEvent(LoggerEvent loggerEvent) {
if (ctor == null)
return true;
return loggerEvent != LoggerEvent.Error;
}
bool IgnoreMessage(LoggerEvent loggerEvent, string format, object[] args) {
if (loggerEvent != LoggerEvent.Error && loggerEvent != LoggerEvent.Warning)
return false;
if (!canIgnoreMessages)
return false;
if (ignoredMessages.ContainsKey(format)) {
numIgnoredMessages++;
return true;
}
ignoredMessages[format] = true;
return false;
}
/// <inheritdoc/>
void ILogger.Log(object sender, LoggerEvent loggerEvent, string format, params object[] args) {
GetLogger().Log(this, loggerEvent, format, args);
}
public static void Log(LoggerEvent loggerEvent, string format, params object[] args) {
Instance.Log(null, loggerEvent, format, args);
}
public bool Accepted(EventWriterTriplet writerTriplet, LoggerEvent loggerEvent, string message)
{
Console.WriteLine("EventWriterFilter.Accepted({0}, {1})", loggerEvent.Id, message);
return true;
}
public void Log(bool canIgnore, object sender, LoggerEvent loggerEvent, string format, params object[] args) {
if (IgnoresEvent(loggerEvent))
return;
if (canIgnore && IgnoreMessage(loggerEvent, format, args))
return;
switch (loggerEvent) {
case LoggerEvent.Error:
foreach (var l in string.Format(format, args).Split('\n'))
LogMessage(string.Empty, string.Format("ERROR: {0}", l));
break;
case LoggerEvent.Warning:
foreach (var l in string.Format(format, args).Split('\n'))
LogMessage(string.Empty, string.Format("WARNING: {0}", l));
break;
default:
var indent = loggerEvent <= LoggerEvent.Warning ? "" : indentString;
LogMessage(indent, format, args);
break;
}
}
public bool IsAcceptedByEventType(LoggerEvent logEvent)
{
return false;
}
void ILogger.Log(object sender, LoggerEvent loggerEvent, string format, params object[] args) {
ThrowIfCanceled();
if (OnLogMessage != null) {
var evtType =
loggerEvent == LoggerEvent.Error ? ModuleSaverLogEvent.Error :
loggerEvent == LoggerEvent.Warning ? ModuleSaverLogEvent.Warning :
ModuleSaverLogEvent.Other;
OnLogMessage(this, new ModuleSaverLogEventArgs(string.Format(format, args), evtType));
}
}
public string Format(LoggerEvent loggerEvent)
{
Console.WriteLine("EventFormatter.Format({0}, {1})", _fieldId, loggerEvent.Id);
return loggerEvent[_fieldId].ToString();
}
bool ILogger.IgnoresEvent(LoggerEvent loggerEvent) {
ThrowIfCanceled();
return false;
}
public void Log(LoggerEvent logEvent)
{
}
/// <inheritdoc/>
bool ILogger.IgnoresEvent(LoggerEvent loggerEvent) {
return GetLogger().IgnoresEvent(loggerEvent);
}
public bool Accepted(LoggerEvent logEvent)
{
Console.WriteLine("EventFilter.Accepted({0})", logEvent.Id);
return true;
}
