public static void LogExt(this NLog.Logger logger, NLog.LogLevel level, string message, string userName, string functional)
{
NLog.LogEventInfo theEvent = new NLog.LogEventInfo(level, logger.Name, message);
theEvent.Properties["UserName"] = userName;
theEvent.Properties["Functional"] = functional;
logger.Log(theEvent);
}
/// <summary>记录详细日志</summary>
public static void Log(NLog.LogLevel logLevel, string message, string request, string principal, string source, string content, string data)
{
var logger = Get <NLog.ILogger>();
var theEvent = new NLog.LogEventInfo(logLevel, logger.Name, message);
if (request != null)
{
theEvent.Properties[nameof(PKS_Log.Request)] = request;
}
if (principal != null)
{
theEvent.Properties[nameof(PKS_Log.Principal)] = principal;
}
if (source != null)
{
theEvent.Properties[nameof(PKS_Log.ExSource)] = source;
}
if (content != null)
{
theEvent.Properties[nameof(PKS_Log.ExContent)] = content;
}
if (data != null)
{
theEvent.Properties[nameof(PKS_Log.ExData)] = data;
}
logger.Log(theEvent);
}
public void Log(LogLevel level, string message, Exception exception)
{
var le = new NLog.LogEventInfo(GetLevell(level), _logger.Name, message);
le.Exception = exception;
_logger.Log(typeof(NLogAdapter), le);
}
public void Log(LogLevel level, string message, params object[] parameters)
{
var le = new NLog.LogEventInfo(GetLevell(level)
, _logger.Name, string.Format(message, parameters));
_logger.Log(typeof(NLogAdapter), le);
}
public void CanDuckTypeLogInfoInModernNLog()
{
var instance = LogEventInfo.Create(
logLevel: LogLevel.Fatal,
loggerName: "LoggerName",
message: "Some message {Value}",
exception: new InvalidOperationException(),
formatProvider: null,
parameters: new object[] { 123 });
var duck = instance.DuckCast <ILogEventInfoProxy>();
duck.Should().NotBeNull();
duck.Level.Should().NotBeNull();
duck.Level.Ordinal.Should().Be(LogLevel.Fatal.Ordinal);
duck.FormattedMessage.Should().Be(instance.FormattedMessage);
duck.Exception.Should().Be(instance.Exception);
duck.HasProperties.Should().BeTrue();
var instanceWithoutProperties = LogEventInfo.Create(
logLevel: LogLevel.Fatal,
loggerName: "LoggerName",
message: "Some message");
instanceWithoutProperties.HasProperties.Should().BeFalse();
var duckWithoutProperties = instanceWithoutProperties.DuckCast <ILogEventInfoProxy>();
duckWithoutProperties.HasProperties.Should().BeFalse();
instanceWithoutProperties.Properties["TestKey"] = "TestValue";
duckWithoutProperties.HasProperties.Should().BeTrue();
duckWithoutProperties.Properties.Should().ContainKey("TestKey").WhoseValue.Should().Be("TestValue");
}
//Dictionary<int, DateTime> lastRecordTime = new Dictionary<int, DateTime>();
//Dictionary<int, DateTime> lastRecordTime = new Dictionary<int, DateTime>();
private void ManagedClient_ApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
{
try
{
//lastTime = DateTime.Now.Add(mqttOptions.RecordInterval);
//byte[] pay_load = e.ApplicationMessage.Payload;
//byte[] new_fileArray = new byte[pay_load.Length + 8];
//Array.Copy(pay_load, new_fileArray, pay_load.Length);
//File.WriteAllBytes($"{DateTime.Now.TimeOfDay}_dump.bin", e.ApplicationMessage.Payload);
DaegunPacket packet = PacketParser.ByteToStruct <DaegunPacket>(e.ApplicationMessage.Payload);
//if (lastRecordTime.ContainsKey(packet.sSiteId) == false)
// lastRecordTime.Add(packet.sSiteId, DateTime.MinValue);
//if (DateTime.Now < lastRecordTime[packet.sSiteId])
// return;
_logger.LogInformation($"RECEIVED DAEGUN : siteid({packet.sSiteId}) from({e.ClientId}) t({e.ApplicationMessage.Topic}) QoS({e.ApplicationMessage.QualityOfServiceLevel}) size({e.ApplicationMessage.Payload.Length})");
//nLogger.Info($"RECEIVED DAEGUN : siteid({packet.sSiteId}) from({e.ClientId}) t({e.ApplicationMessage.Topic}) QoS({e.ApplicationMessage.QualityOfServiceLevel}) size({e.ApplicationMessage.Payload.Length})");
//lastRecordTime[packet.sSiteId] = DateTime.Now.Add(mqttOptions.RecordInterval);
//packet.timestamp = DateTime.Now;
DateTime dt = DateTime.Now.Date
.AddHours(DateTime.Now.Hour)
.AddMinutes(DateTime.Now.Minute)
.AddSeconds(DateTime.Now.Second);
#if RASPIAN == false
queue.QueueBackgroundWorkItem(new DaegunPacketClass(packet, dt));
#else
NLog.LogEventInfo pcsEventInfo = LogEventMaker.CreateLogEvent(PCS_LOG, packet.Pcs);
NLog.LogEventInfo bscEventInfo = LogEventMaker.CreateLogEvent(BSC_LOG, packet.Bsc);
NLog.LogEventInfo pvEventInfo = LogEventMaker.CreateLogEvent(PV_METER_LOG, packet.Pv);
NLog.LogEventInfo essEventInfo = LogEventMaker.CreateLogEvent(BSC_METER_LOG, packet.Ess);
//NLog.Logger logger = NLog.LogManager.Configuration.LogFactory.GetLogger("record.pcs");
//NLog.LogEventInfo logEvent = LogEventMaker.CreateLogEvent("record.pcs", pcsPacket);
pcsEventInfo.Properties["SiteId"] =
bscEventInfo.Properties["SiteId"] =
pvEventInfo.Properties["SiteId"] =
essEventInfo.Properties["SiteId"] = packet.sSiteId;
pcsLogger.Log(pcsEventInfo);
bscLogger.Log(bscEventInfo);
pvMeterLogger.Log(pvEventInfo);
bscMeterLogger.Log(essEventInfo);
//logger.Log(logEvent);
#endif
//logger.LogInformation("Store Daegun Packet");
//if(lastRecordTime.ContainsKey(packet.sSiteId) == false)
//{
// lastRecordTime.Add(packet.sSiteId, DateTime.MinValue);
//}
//if (DateTime.Now > lastRecordTime[packet.sSiteId])
//{
// lastRecordTime[packet.sSiteId] = DateTime.Now.Add(mqttOptions.RecordInterval);
//}
}catch (Exception ex)
{
Console.WriteLine(ex.Message);
_logger.LogError(ex, ex.Message);
}
}
public override void LogCore(LogItem item)
{
NLog.LogLevel nlogLogLevel = ToNLogLevel(item.Level);
//if (IsEnabled(nlogLogLevel))
//{
NLog.LogEventInfo logItem = new NLog.LogEventInfo();
logItem.Level = nlogLogLevel;
logItem.TimeStamp = DateTime.UtcNow;
logItem.Message = item.Message?.ToString();
logItem.Properties[CategoryContext] = item.Category;
logItem.Exception = item.Exception;
logItem.LoggerName = logger.Name;
if (item.Properties != null)
{
foreach (var pair in item.Properties)
{
logItem.Properties.Add(pair.Key, pair.Value);
}
}
logger.Log(logItem);
if (logItem.Exception != null)
{
var except = logItem.Exception.ToExceptionless();
except.Submit();
}
else if (item.Level == LogLevel.Error || item.Level == LogLevel.Warn || item.Level == LogLevel.Fatal || item.Level == LogLevel.Info)
{
ExceptionlessClient.Default.SubmitLog(item.Category, logItem.Message, ToExceptionlessLevel(item.Level));
}
OutputToConsole(item);
}
private static void LogEvent(NLog.LogLevel logLevel, string loggerName, string message, Exception exception, params object[] args)
{
NLog.LogEventInfo logEventInfo = new NLog.LogEventInfo(logLevel, loggerName, message);
if (exception != null)
{
// Get any additional data that might have been passed into the exception.Data collection
System.Text.StringBuilder sbAdditionalData = new System.Text.StringBuilder();
foreach (object key in exception.Data.Keys)
{
sbAdditionalData.AppendFormat("{0}: {1} ~ ", key.ToString(), exception.Data[key].ToString());
}
logEventInfo.Exception = exception;
logEventInfo.Properties["AdditionalData"] = sbAdditionalData.ToString();
}
if (args != null)
{
logEventInfo.Parameters = args;
}
_logger.Log(logEventInfo);
}
protected override void Write(NLog.LogEventInfo logEvent)
{
var msg = Layout.Render(logEvent);
var lvl = logEvent.Level;
UlsLogger.Log(lvl, msg);
}
private void SetLogEntryProperties(Dictionary <string, object> meta, NLog.LogEventInfo entry)
{
if (meta == null)
{
meta = new Dictionary <string, object>();
}
if (!meta.ContainsKey("ClientId"))
{
meta["ClientId"] = clientId;
}
if (!string.IsNullOrWhiteSpace(loggerTaskId))
{
if (!meta.ContainsKey("TaskId"))
{
meta["TaskId"] = loggerTaskId;
}
}
foreach (var item in meta)
{
entry.Properties[item.Key] = item.Value;
}
}
/// <inheritdoc />
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter)
{
// First we take care about output to console.
if (this.consoleLogger.IsEnabled(logLevel))
{
this.consoleLogger.Log(logLevel, eventId, state, exception, (s, e) => { return(this.prefix + formatter(s, e)); });
}
// The rest of the method cares about logging via NLog to files.
NLog.LogLevel nLogLevel = logLevel.ToNLogLevel();
if (!this.IsEnabled(nLogLevel))
{
return;
}
if (formatter == null)
{
throw new ArgumentNullException(nameof(formatter));
}
string message = this.prefix + formatter(state, exception);
NLog.LogEventInfo eventInfo = NLog.LogEventInfo.Create(nLogLevel, this.logger.Name, message);
eventInfo.Exception = exception;
this.logger.Log(this.wrapperType, eventInfo);
}
public static void Log(LogLevel level, object sender, string message, params object[] args)
{
string typeName = (sender == null ? "(null)" : sender.GetType ().FullName);
LogEventInfo info = new LogEventInfo (_levelMap[level], typeName, string.Format (message, args));
info.Context.Add ("sender", sender);
_logger.Log (info);
}
public void Write()
{
var logEvent = new NLog.LogEventInfo(LogLevel.Debug, "Test.Logger", "This is a test message.");
var asyncLogEventInfo = new NLog.Common.AsyncLogEventInfo(logEvent, ex =>
{
if (ex != null)
{
Console.WriteLine(ex);
}
});
var target = new MessageQueueTarget();
target.CreateQueueIfNotExists = true;
target.Label = new SimpleLayout("${logger}");
target.Layout = new XmlLayout();
target.Name = "messageQueue";
target.Queue = new SimpleLayout(@".\private$\logging");
target.Recoverable = true;
target.WriteAsyncLogEvent(asyncLogEventInfo);
Thread.Sleep(5000);
}
public void Log(LogLevel level, string message, params object[] parameters)
{
var le = new NLog.LogEventInfo(GetLevell(level)
, _logger.Name, string.Format(message, parameters));
_logger.Log(typeof(NLogAdapter), le);
}
private void LogMessage(int level, string message = "", [CallerMemberName] string method = "")
{
NLog.LogLevel logLevel;
switch (level)
{
case 0:
logLevel = NLog.LogLevel.Trace;
break;
case 1:
logLevel = NLog.LogLevel.Debug;
break;
case 2:
logLevel = NLog.LogLevel.Info;
break;
case 3:
logLevel = NLog.LogLevel.Warn;
break;
case 4:
logLevel = NLog.LogLevel.Error;
break;
default:
logLevel = NLog.LogLevel.Fatal;
break;
}
var logMessage = $"{_className}.{method}{((string.IsNullOrEmpty(message)) ? ("") : (": "))}{message??""}";
var lInfo = new NLog.LogEventInfo(logLevel, _className, logMessage);
_logger.Log(lInfo);
}
public void CanReverseDuckTypeTarget()
{
var targetType = typeof(Target);
var target = NLogHelper.CreateTarget(new NullDatadogSink(), DirectSubmissionLogLevel.Debug);
var proxy = NLogCommon <Target> .CreateNLogTargetProxy(target);
proxy.Should().NotBeNull();
proxy.GetType().Should().BeDerivedFrom(targetType);
var message = "the message";
var logInfo = new AsyncLogEventInfo(LogEventInfo.Create(LogLevel.Error, "test", message), _ => { });
var typedProxy = ((Target)proxy);
typedProxy.WriteAsyncLogEvent(logInfo); // should not throw
#if NLOG_45
var proxyOfProxy = proxy.DuckCast <ITargetWithContextBaseProxy>();
proxyOfProxy.Should().NotBeNull();
var results = proxyOfProxy.GetAllProperties(logInfo.LogEvent.DuckCast <ILogEventInfoProxy>());
results.Should().NotBeNull();
target.SetBaseProxy(proxyOfProxy);
#endif
}
public void CanDuckTypeLogInfoInLegacyNLog()
{
#if NLOG_2
var instance = new LogEventInfo(
level: LogLevel.Fatal,
loggerName: "LoggerName",
message: "Some message {0}",
exception: new InvalidOperationException(),
formatProvider: null,
parameters: new object[] { 123 });
#else
var instance = LogEventInfo.Create(
logLevel: LogLevel.Fatal,
loggerName: "LoggerName",
message: "Some message {0}",
exception: new InvalidOperationException(),
formatProvider: null,
parameters: new object[] { 123 });
#endif
var duck = instance.DuckCast <LogEventInfoLegacyProxy>();
duck.Should().NotBeNull();
duck.Level.Should().NotBeNull();
duck.Level.Ordinal.Should().Be(LogLevel.Fatal.Ordinal);
duck.LoggerName.Should().Be(instance.LoggerName);
duck.FormattedMessage.Should().Be(instance.FormattedMessage);
duck.Exception.Should().Be(instance.Exception);
duck.HasProperties.Should().BeFalse();
instance.Properties["TestKey"] = "TestValue";
duck.HasProperties.Should().BeTrue();
duck.Properties.Should().ContainKey("TestKey").WhichValue.Should().Be("TestValue");
}
public void Log(LogLevel level, string message, Exception exception)
{
var le = new NLog.LogEventInfo(GetLevell(level), _logger.Name, message);
le.Exception = exception;
_logger.Log(typeof(NLogAdapter), le);
}
public static NLog.LogEventInfo CreateLogEvent(string loggerName, object target)
{
var logEvent = new NLog.LogEventInfo(NLog.LogLevel.Trace, loggerName, "");
var properties = target.GetType().GetFields();
ExportFields(logEvent.Properties, null, target);
return(logEvent);
}
/// <summary>
/// Actually sends the message to the underlying log system.
/// </summary>
/// <param name="logLevel">the level of this log event.</param>
/// <param name="message">the message to log</param>
/// <param name="exception">the exception to log (may be null)</param>
protected override void WriteInternal(LogLevel logLevel, object message, Exception exception)
{
LogLevelNLog level = GetLevel(logLevel);
NLog.LogEventInfo logEvent = new NLog.LogEventInfo(level, this.logger.Name, null, "{0}", new object[] { message }, exception);
logger.Log(declaringType, logEvent);
}
internal static void LogMessage(LogEventId eventId, LogLevel level, string message, Exception exception, IDictionary <object, object> properties)
{
var type = typeof(T);
NLog.Logger logger = NLog.LogManager.GetLogger(type.FullName);
NLog.LogLevel logLevel = NLog.LogLevel.Info; // Default level to info
switch (level)
{
case LogLevel.Warn:
logLevel = NLog.LogLevel.Warn;
break;
case LogLevel.Info:
logLevel = NLog.LogLevel.Info;
break;
case LogLevel.Fatal:
logLevel = NLog.LogLevel.Fatal;
break;
case LogLevel.Error:
logLevel = NLog.LogLevel.Error;
break;
case LogLevel.Debug:
logLevel = NLog.LogLevel.Debug;
break;
case LogLevel.Trace:
logLevel = NLog.LogLevel.Trace;
break;
}
NLog.LogEventInfo logEvent = new NLog.LogEventInfo(logLevel, type.Name, message);
logEvent.Exception = exception;
CombineProperties(logEvent.Properties, properties);
if (logEvent.Properties.ContainsKey(LoggingAttributes.LOG_OBJECT))
{
logEvent.Properties[LoggingAttributes.LOG_OBJECT] =
Newtonsoft.Json.JsonConvert.SerializeObject(logEvent.Properties[LoggingAttributes.LOG_OBJECT]);
}
//Add event id to the properties
if (!logEvent.Properties.ContainsKey("EventId.Id"))
{
logEvent.Properties.Add("EventId.Id", (int)eventId);
}
else
{
logEvent.Properties["EventId.Id"] = (int)eventId;
}
logger.Log(type, logEvent);
}
public override void Log(LogLevel level, string message)
{
NLog.LogLevel nlogLevel = GetNLogLevel(level);
var ei = new NLog.LogEventInfo(nlogLevel, _logger.Name, message);
ei.Properties["AppID"] = _appID;
ei.Properties["InstanceID"] = _instanceID;
_logger.Log(ei);
}
public override void Log <T>(LogLevel level, T message)
{
NLog.LogLevel nlogLevel = GetNLogLevel(level);
var ei = new NLog.LogEventInfo(nlogLevel, _logger.Name, JsonConvert.SerializeObject(message));
ei.Properties["AppID"] = _appID;
ei.Properties["InstanceID"] = _instanceID;
_logger.Log(ei);
}
public static void Info(Entity.media_option_log loginfo)
{
NLog.LogEventInfo eventInfo = new NLog.LogEventInfo(NLog.LogLevel.Info, "", "");
foreach (var pro in typeof(Entity.media_option_log).GetProperties())
{
eventInfo.Properties[pro.Name] = pro.GetValue(loginfo);
}
logger.Info(eventInfo);
}
public override void ExtendLogEvent(NLog.LogEventInfo logEvent)
{
base.ExtendLogEvent(logEvent);
if (!string.IsNullOrEmpty(this.LogFile))
{
logEvent.Properties.Add("logFile", this.LogFile);
}
}
public void Log(LogLevel logLevel, LogType logType, string msg, string data)
{
NLog.LogEventInfo log = new NLog.LogEventInfo(NLog.LogLevel.FromString(logLevel.ToString()), "sysLogger", msg);
log.Properties[LoggerConfig.Data] = data;
log.Properties[LoggerConfig.LogType] = logType.ToString();
log.Properties[LoggerConfig.OpUserName] = _operator?.Property?.UserName;
_nLogger.Log(log);
}
protected void LogBadRequest(BadRequestEntity badRequest)
{
if (badRequest != null)
{
NLog.LogEventInfo theEvent = new NLog.LogEventInfo(NLog.LogLevel.Error, "", "");
theEvent.Properties["Method"] = badRequest.Method;
theEvent.Properties["Exeption"] = badRequest.Exeption;
_logger.Error(theEvent);
}
}
protected override void Write(NLog.LogEventInfo logEvent)
{
Microsoft.Extensions.Logging.LogLevel level;
if (!_levelMapping.TryGetValue(logEvent.Level, out level))
{
level = Microsoft.Extensions.Logging.LogLevel.Information;
}
_logger.Log(level, 0, logEvent, logEvent.Exception, MessageFormatter);
}
protected void LogProcessingInfo(RequestProcessingEntity requestProcessing)
{
if (requestProcessing != null)
{
NLog.LogEventInfo theEvent = new NLog.LogEventInfo(NLog.LogLevel.Info, "", "");
theEvent.Properties["HTTPMethod"] = requestProcessing.Method;
theEvent.Properties["Path"] = requestProcessing.Path;
theEvent.Properties["StatusCode"] = requestProcessing.StatusCode;
_logger.Info(theEvent);
}
}
public override void Log(ExceptionLoggerContext context)
{
var logEventInfo = new NLog.LogEventInfo(NLog.LogLevel.Error, Logger.Name,
CultureInfo.InvariantCulture,
RequestToString(context.Request),
null,
context.Exception);
//logEventInfo.Properties[""];
Logger.Log(GetType(), logEventInfo);
}
protected override void Write(NLog.LogEventInfo logEvent)
{
var msg = AppendException(logEvent.FormattedMessage, logEvent.Exception);
_buffer.Add(new LogMessage {
Level = logEvent.Level,
Message = msg,
Source = logEvent.LoggerName,
Timestamp = logEvent.TimeStamp
});
}
protected override void Append(StringBuilder builder, NLog.LogEventInfo logEvent)
{
var actionName = string.Empty;
if (HttpContext.Current != null)
{
actionName = HttpContext.Current.Request.RequestContext.RouteData.Values["action"].ToString();
}
builder.Append(actionName);
}
private static Action <DateTime, int, string, Exception> NLogLogHandlerProvider(string loggerName)
{
var nLogLogger = NLog.LogManager.GetLogger(loggerName);
return(new Action <DateTime, int, string, Exception>(delegate(DateTime timeStamp, int logLevel, string message, Exception exception)
{
NLog.LogEventInfo logEvent = new NLog.LogEventInfo(_nLogLogLevelArray[logLevel], loggerName, message);
logEvent.TimeStamp = timeStamp;
nLogLogger.Log(logEvent);
}));
}
public void Write()
{
var logEvent = new NLog.LogEventInfo(LogLevel.Debug, "Test.Logger", "This is a test message.");
var asyncLogEventInfo = new NLog.Common.AsyncLogEventInfo(logEvent, ex =>
{
if (ex != null) Console.WriteLine(ex);
});
var target = new MessageQueueTarget();
target.CreateQueueIfNotExists = true;
target.Label = new SimpleLayout("${logger}");
target.Layout = new XmlLayout();
target.Name = "messageQueue";
target.Queue = new SimpleLayout(@".\private$\logging");
target.Recoverable = true;
target.WriteAsyncLogEvent(asyncLogEventInfo);
Thread.Sleep(5000);
}
protected override void Append(StringBuilder builder, LogEventInfo logEvent)
{
IAnonymousRouter ar = logEvent.Context["sender"] as IAnonymousRouter;
if (ar == null) return;
builder.Append (ar.KeyBasedRouter.SelftNodeId.ToString ().Substring (0, KeyShortLength));
}
protected override int GetEstimatedBufferSize(LogEventInfo logEvent)
{
return 128;
}
protected override void Append(StringBuilder builder, LogEventInfo logEvent)
{
ISubscribeInfo subscribe = logEvent.Context["sender"] as ISubscribeInfo;
if (subscribe == null) return;
builder.Append (subscribe.AnonymousRouter.KeyBasedRouter.SelftNodeId.ToString ().Substring (0, KeyShortLength));
builder.Append ('+');
builder.Append (subscribe.Key.ToString ().Substring (0, KeyShortLength));
}
