public RenderMessage ( IFormatProvider formatProvider = null ) : string | ||
formatProvider | IFormatProvider | Supplies culture-specific formatting information, or null. |
return | string |
public static EventBuilder CreateFromLogEvent(this ExceptionlessClient client, LogEvent log) { var builder = log.Exception != null ? client.CreateException(log.Exception) : client.CreateLog(log.GetSource(), log.RenderMessage(), log.GetLevel()); builder.Target.Date = log.Timestamp; if (log.Level == LogEventLevel.Fatal) builder.MarkAsCritical(); if (!String.IsNullOrWhiteSpace(log.RenderMessage())) builder.SetMessage(log.RenderMessage()); return builder; }
private LogglyEvent CreateLogglyEvent(LogEvent logEvent) { var logglyEvent = new LogglyEvent(); var isHttpTransport = LogglyConfig.Instance.Transport.LogTransport == LogTransport.Https; logglyEvent.Syslog.Level = ToSyslogLevel(logEvent); foreach (var key in logEvent.Properties.Keys) { var propertyValue = logEvent.Properties[key]; var simpleValue = LogglyPropertyFormatter.Simplify(propertyValue); logglyEvent.Data.AddIfAbsent(key, simpleValue); } logglyEvent.Data.AddIfAbsent("Message", logEvent.RenderMessage(_formatProvider)); if (isHttpTransport) { // syslog will capture these via the header logglyEvent.Data.AddIfAbsent("Level", logEvent.Level.ToString()); } if (logEvent.Exception != null) { logglyEvent.Data.AddIfAbsent("Exception", logEvent.Exception); } return logglyEvent; }
private void FormatInternal(LogEvent logEvent, TextWriter output) { if (logEvent == null) throw new ArgumentNullException("logEvent"); if (output == null) throw new ArgumentNullException("output"); if (!_omitEnclosingObject) output.Write("{"); var precedingDelimiter1 = ""; WriteJsonProperty("Timestamp", logEvent.Timestamp, ref precedingDelimiter1, output); WriteJsonProperty("Level", logEvent.Level, ref precedingDelimiter1, output); WriteJsonProperty("Message", logEvent.RenderMessage(), ref precedingDelimiter1, output); WriteJsonProperty("MessageTemplate", logEvent.MessageTemplate.Text, ref precedingDelimiter1, output); if (logEvent.Exception != null) WriteJsonProperty("Exception", logEvent.Exception, ref precedingDelimiter1, output); if (logEvent.Properties.Count != 0) { output.Write(",\"Properties\":{"); var precedingDelimiter2 = ""; foreach (KeyValuePair<string, LogEventPropertyValue> keyValuePair in logEvent.Properties) WriteJsonProperty(keyValuePair.Key, keyValuePair.Value, ref precedingDelimiter2, output); output.Write("}"); } if (_omitEnclosingObject) return; output.Write("}"); }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { var renderedMessage = logEvent.RenderMessage(_formatProvider); // take logEvent and use it for the corresponding ITelemetry counterpart if (logEvent.Exception != null) { var exceptionTelemetry = new ExceptionTelemetry(logEvent.Exception) { SeverityLevel = logEvent.Level.ToSeverityLevel(), HandledAt = ExceptionHandledAt.UserCode, Timestamp = logEvent.Timestamp }; // write logEvent's .Properties to the AI one ForwardLogEventPropertiesToTelemetryProperties(exceptionTelemetry, logEvent, renderedMessage); _telemetryClient.TrackException(exceptionTelemetry); } else { var eventTelemetry = new EventTelemetry(logEvent.MessageTemplate.Text) { Timestamp = logEvent.Timestamp }; // write logEvent's .Properties to the AI one ForwardLogEventPropertiesToTelemetryProperties(eventTelemetry, logEvent, renderedMessage); _telemetryClient.TrackEvent(eventTelemetry); } }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { var error = logEvent.Exception != null ? new Error(logEvent.Exception) : new Error(); error.Message = logEvent.RenderMessage(_formatProvider); error.Time = logEvent.Timestamp.DateTime; _errorLog.Log(error); }
public void Emit(LogEvent logEvent) { var text = logEvent.RenderMessage(); using (var writer = new StringWriter()) { new ElasticsearchJsonFormatter().Format(logEvent, writer); var str = writer.ToString(); //Console.WriteLine(str); } }
public void Emit(LogEvent logEvent) { LogEventPropertyValue contextValue; if (!logEvent.Properties.TryGetValue(Constants.SourceContextPropertyName, out contextValue)) { return; } var scalar = contextValue as ScalarValue; if (scalar == null) return; var @group = (string)scalar.Value; _context.Clients.Group(@group).NewMessage(new StatusMessage { Message = logEvent.RenderMessage(_formatProvider) }); }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { var message = new Message(logEvent.RenderMessage(_formatProvider)) { Severity = LevelToSeverity(logEvent), DateTime = logEvent.Timestamp.DateTime.ToUniversalTime(), Detail = logEvent.Exception != null ? logEvent.Exception.ToString() : null, Data = PropertiesToData(logEvent), }; _logger.Log(message); }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { //Include the log level as a tag. var tags = _tags.Concat(new []{logEvent.Level.ToString()}).ToList(); var properties = logEvent.Properties .Select(pv => new { Name = pv.Key, Value = RaygunPropertyFormatter.Simplify(pv.Value) }) .ToDictionary(a => a.Name, b => b.Value); // Add the message properties.Add("RenderedLogMessage", logEvent.RenderMessage(_formatProvider)); properties.Add("LogMessageTemplate", logEvent.MessageTemplate.Text); // Create new message var raygunMessage = new RaygunMessage { OccurredOn = logEvent.Timestamp.UtcDateTime }; // Add exception when available if (logEvent.Exception != null) raygunMessage.Details.Error = new RaygunErrorMessage(logEvent.Exception); // Add user when requested if (!String.IsNullOrWhiteSpace(_userNameProperty) && logEvent.Properties.ContainsKey(_userNameProperty) && logEvent.Properties[_userNameProperty] != null) { raygunMessage.Details.User = new RaygunIdentifierMessage(logEvent.Properties[_userNameProperty].ToString()); } // Add version when requested if (!String.IsNullOrWhiteSpace(_applicationVersionProperty) && logEvent.Properties.ContainsKey(_applicationVersionProperty) && logEvent.Properties[_applicationVersionProperty] != null) { raygunMessage.Details.Version = logEvent.Properties[_applicationVersionProperty].ToString(); } // Build up the rest of the message raygunMessage.Details.Environment = new RaygunEnvironmentMessage(); raygunMessage.Details.Tags = tags; raygunMessage.Details.UserCustomData = properties; raygunMessage.Details.MachineName = Environment.MachineName; if (HttpContext.Current != null) raygunMessage.Details.Request = new RaygunRequestMessage(HttpContext.Current.Request, null); // Submit _client.SendInBackground(raygunMessage); }
/// <summary> /// Create a log event entity from a Serilog <see cref="LogEvent"/>. /// </summary> /// <param name="log">The event to log</param> /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param> public LogEventEntity(LogEvent log, IFormatProvider formatProvider) { Timestamp = log.Timestamp.ToUniversalTime().DateTime; PartitionKey = string.Format("0{0}", Timestamp.Ticks); RowKey = GetValidRowKey(string.Format("{0}|{1}", log.Level, log.MessageTemplate.Text)); MessageTemplate = log.MessageTemplate.Text; Level = log.Level.ToString(); Exception = log.Exception != null ? log.Exception.ToString() : null; RenderedMessage = log.RenderMessage(formatProvider); var s = new StringWriter(); new JsonFormatter(closingDelimiter: "", formatProvider: formatProvider).Format(log, s); Data = s.ToString(); }
/// <summary> /// Construct a new <seealso cref="LogEventEntity"/>. /// </summary> public LogEventEntity(LogEvent logEvent, IFormatProvider formatProvider) { TimeStamp = logEvent.Timestamp; Exception = logEvent.Exception; MessageTemplate = logEvent.MessageTemplate.Text; Level = logEvent.Level; RenderedMessage = logEvent.RenderMessage(formatProvider); Properties = new Dictionary<string, LogEventProperty>(); foreach (var pair in logEvent.Properties) { Properties.Add(pair); } }
async Task EmitAsync(LogEvent logEvent) { if (hubConnection.State == ConnectionState.Disconnected) await hubConnection.Start(); var liveEvent = new LiveEvent { Timestamp = logEvent.Timestamp, Level = (LiveEventLevel)logEvent.Level, Message = logEvent.RenderMessage(), Template = logEvent.MessageTemplate.Text, }; await hubProxy.Invoke<LiveEvent>("log", liveEvent); }
/// <summary> /// Creates a DynamicTableEntity for Azure Storage, given a Serilog <see cref="LogEvent"/>.Properties /// are stored as separate columns. /// </summary> /// <param name="logEvent">The event to log</param> /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param> /// <param name="additionalRowKeyPostfix">Additional postfix string that will be appended to row keys</param> /// <returns></returns> public static DynamicTableEntity CreateEntityWithProperties(LogEvent logEvent, IFormatProvider formatProvider, string additionalRowKeyPostfix) { var tableEntity = new DynamicTableEntity(); tableEntity.PartitionKey = GenerateValidPartitionKey(logEvent); tableEntity.RowKey = GenerateValidRowKey(logEvent, additionalRowKeyPostfix); tableEntity.Timestamp = logEvent.Timestamp; var dynamicProperties = tableEntity.Properties; dynamicProperties.Add("MessageTemplate", new EntityProperty(logEvent.MessageTemplate.Text)); dynamicProperties.Add("Level", new EntityProperty(logEvent.Level.ToString())); dynamicProperties.Add("RenderedMessage", new EntityProperty(logEvent.RenderMessage(formatProvider))); if (logEvent.Exception != null) { dynamicProperties.Add("Exception", new EntityProperty(logEvent.Exception.ToString())); } List<KeyValuePair<ScalarValue, LogEventPropertyValue>> additionalData = null; int count = dynamicProperties.Count; foreach (var logProperty in logEvent.Properties) { if (count++ < _maxNumberOfPropertiesPerRow - 1) { dynamicProperties.Add(logProperty.Key, AzurePropertyFormatter.ToEntityProperty(logProperty.Value, null, formatProvider)); } else { if (additionalData == null) { additionalData = new List<KeyValuePair<ScalarValue, LogEventPropertyValue>>(); } additionalData.Add(new KeyValuePair<ScalarValue, LogEventPropertyValue>(new ScalarValue(logProperty.Key), logProperty.Value)); } } if (additionalData != null) { dynamicProperties.Add("AggregatedProperties", AzurePropertyFormatter.ToEntityProperty(new DictionaryValue(additionalData), null, formatProvider)); } return tableEntity; }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { // Create a new FluentEvent for Loggr based on the exception or the properties. var ev = logEvent.Exception != null ? global::Loggr.Events.CreateFromException(logEvent.Exception) : global::Loggr.Events.CreateFromVariable(logEvent.Properties); ev.Text(logEvent.RenderMessage(_formatProvider)); ev.AddTags(logEvent.Level.ToString()); if (!String.IsNullOrWhiteSpace(_userNameProperty) && logEvent.Properties.ContainsKey(_userNameProperty) && logEvent.Properties[_userNameProperty] != null) { ev.User(logEvent.Properties[_userNameProperty].ToString()); } ev.UseLogClient(_client); ev.Post(true); }
public void Emit(LogEvent logEvent) { var loggerName = _defaultLoggerName; LogEventPropertyValue sourceContext; if (logEvent.Properties.TryGetValue(Constants.SourceContextPropertyName, out sourceContext)) { var sv = sourceContext as ScalarValue; if (sv != null && sv.Value is string) loggerName = (string)sv.Value; } var message = logEvent.RenderMessage(_formatProvider); var exception = logEvent.Exception; var logger = LogManager.GetLogger(loggerName); using (_supplyContextMessage ? ThreadContext.Stacks["NDC"].Push(ContextMessage) : new NullDisposable()) { switch (logEvent.Level) { case LogEventLevel.Verbose: case LogEventLevel.Debug: logger.Debug(message, exception); break; case LogEventLevel.Information: logger.Info(message, exception); break; case LogEventLevel.Warning: logger.Warn(message, exception); break; case LogEventLevel.Error: logger.Error(message, exception); break; case LogEventLevel.Fatal: logger.Fatal(message, exception); break; default: SelfLog.WriteLine("Unexpected logging level, writing to log4net as Info"); logger.Info(message, exception); break; } } }
public void Emit(LogEvent logEvent) { var level = TranslateLogLevel(logEvent.Level); var source = string.Empty; if (logEvent.Properties.ContainsKey("SourceContext")) { var ctx = logEvent.Properties["SourceContext"] as ScalarValue; source = ctx != null ? ctx.Value.ToString() : string.Empty; } _entries.Add(new LogEntry { Level = level, Message = logEvent.RenderMessage(), Source = source, Timestamp = logEvent.Timestamp }); }
public void Emit(LogEvent logEvent) { var body = logEvent.RenderMessage(); var request = System.Net.WebRequest.Create(Uri); request.Method = HttpMethod; request.ContentType = ContentType; request.Headers.Add(Headers); using (var stream = request.GetRequestStream()) { var bytes = Encoding.UTF8.GetBytes(body); stream.Write(bytes, 0, bytes.Length); } var response = request.GetResponse(); return; }
public void Emit(LogEvent logEvent) { string loggerName = null; LogEventPropertyValue sourceContext; if (logEvent.Properties.TryGetValue("SourceContext", out sourceContext)) { var sv = sourceContext as ScalarValue; if (sv != null && sv.Value is string) loggerName = (string)sv.Value; } var message = logEvent.RenderMessage(_formatProvider); var exception = logEvent.Exception; var logger = LogManager.GetLogger(loggerName); switch (logEvent.Level) { case LogEventLevel.Verbose: case LogEventLevel.Debug: logger.Debug(message, exception); break; case LogEventLevel.Information: logger.Info(message, exception); break; case LogEventLevel.Warning: logger.Warn(message, exception); break; case LogEventLevel.Error: logger.Error(message, exception); break; case LogEventLevel.Fatal: logger.Fatal(message, exception); break; default: SelfLog.WriteLine("Unexpected logging level, writing to log4net as Info"); logger.Info(message, exception); break; } }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { var category = "info"; switch (logEvent.Level) { case LogEventLevel.Verbose: case LogEventLevel.Debug: category = "verbose"; break; case LogEventLevel.Information: category = "info"; break; case LogEventLevel.Warning: category = "warning"; break; case LogEventLevel.Error: case LogEventLevel.Fatal: category = "error"; break; default: SelfLog.WriteLine("Unexpected logging level, writing to loggly as Info"); break; } var properties = logEvent.Properties .Select(pv => new { Name = pv.Key, Value = LogglyPropertyFormatter.Simplify(pv.Value) }) .ToDictionary(a => a.Name, b => b.Value); if (logEvent.Exception != null) properties.Add("Exception", logEvent.Exception); _client.Log(logEvent.RenderMessage(_formatProvider), category, properties); }
public void Emit(LogEvent logEvent) { var loggerName = "Default"; LogEventPropertyValue sourceContext; if (logEvent.Properties.TryGetValue(Constants.SourceContextPropertyName, out sourceContext)) { var sv = sourceContext as ScalarValue; if (sv != null && sv.Value is string) { loggerName = (string)sv.Value; } } var level = GetMappedLevel(logEvent); var message = logEvent.RenderMessage(formatProvider); var exception = logEvent.Exception; var nlogEvent = new LogEventInfo(level, loggerName, message) { Exception = exception }; // pass along the event's properties to nlog foreach (var property in logEvent.Properties) { // format simple scalar strings as literals (without wrapping quotes), which is more likely to be what nlog users expect var sv = property.Value as ScalarValue; var format = (sv != null && sv.Value is string) ? "l" : null; nlogEvent.Properties[property.Key] = property.Value.ToString(format, null); } var logger = LogManager.GetLogger(loggerName); logger.Log(nlogEvent); }
/// <summary> /// Format the log event into the output. /// </summary> /// <param name="logEvent">The event to format.</param> /// <param name="output">The output.</param> public void Format(LogEvent logEvent, TextWriter output) { if (logEvent == null) throw new ArgumentNullException("logEvent"); if (output == null) throw new ArgumentNullException("output"); if (!_omitEnclosingObject) output.Write("{"); var delim = ""; WriteJsonProperty("Timestamp", logEvent.Timestamp, ref delim, output); WriteJsonProperty("Level", logEvent.Level, ref delim, output); WriteJsonProperty("MessageTemplate", logEvent.MessageTemplate.Text, ref delim, output); if (_renderMessage) WriteJsonProperty("RenderedMessage", logEvent.RenderMessage(_formatProvider), ref delim, output); if (logEvent.Exception != null) WriteJsonProperty("Exception", logEvent.Exception, ref delim, output); if (logEvent.Properties.Count != 0) { output.Write(",\"Properties\":{"); var pdelim = ""; foreach (var property in logEvent.Properties) { WriteJsonProperty(property.Key, property.Value, ref pdelim, output); } output.Write("}"); } if (!_omitEnclosingObject) { output.Write("}"); output.Write(_closingDelimiter); } }
/// <summary> /// Format the log event into the output. /// </summary> /// <param name="logEvent">The event to format.</param> /// <param name="output">The output.</param> public void Format(LogEvent logEvent, TextWriter output) { if (logEvent == null) throw new ArgumentNullException("logEvent"); if (output == null) throw new ArgumentNullException("output"); if (!_omitEnclosingObject) output.Write("{"); var delim = ""; WriteTimestamp(logEvent.Timestamp, ref delim, output); WriteLevel(logEvent.Level, ref delim, output); WriteMessageTemplate(logEvent.MessageTemplate.Text, ref delim, output); if (_renderMessage) { var message = logEvent.RenderMessage(_formatProvider); WriteRenderedMessage(message, ref delim, output); } if (logEvent.Exception != null) WriteException(logEvent.Exception, ref delim, output); if (logEvent.Properties.Count != 0) WriteProperties(logEvent.Properties, output); var tokensWithFormat = logEvent.MessageTemplate.Tokens .OfType<PropertyToken>() .Where(pt => pt.Format != null) .GroupBy(pt => pt.PropertyName) .ToArray(); if (tokensWithFormat.Length != 0) { WriteRenderings(tokensWithFormat, logEvent.Properties, output); } if (!_omitEnclosingObject) { output.Write("}"); output.Write(_closingDelimiter); } }
private Task EmitAsync(LogEvent logEvent) { return _client.CreateDocumentAsync(_collection.SelfLink, new Data.LogEvent(logEvent, logEvent.RenderMessage(_formatProvider))); }
/// <summary> /// Emit the provided log event to the sink. /// </summary> /// <param name="logEvent">The log event to write.</param> public void Emit(LogEvent logEvent) { // this logs the message & its metadata to application insights this._loggingController.LogMessageWithData(logEvent.RenderMessage(this._formatProvider), logEvent, new JsonConverter[] { ApplicationInsightsDictionaryJsonConverter.Instance }); }
/// <summary> /// Format the log event into the output. /// </summary> /// <param name="logEvent">The event to format.</param> /// <param name="output">The output.</param> public void Format(LogEvent logEvent, TextWriter output) { if (logEvent == null) throw new ArgumentNullException("logEvent"); if (output == null) throw new ArgumentNullException("output"); if (!_omitEnclosingObject) output.Write("{"); var delim = ""; WriteJsonProperty("Timestamp", logEvent.Timestamp, ref delim, output); WriteJsonProperty("Level", logEvent.Level, ref delim, output); WriteJsonProperty("MessageTemplate", logEvent.MessageTemplate.Text, ref delim, output); if (_renderMessage) WriteJsonProperty("RenderedMessage", logEvent.RenderMessage(_formatProvider), ref delim, output); if (logEvent.Exception != null) WriteJsonProperty("Exception", logEvent.Exception, ref delim, output); if (logEvent.Properties.Count != 0) { output.Write(",\"Properties\":{"); var precedingDelimiter = ""; foreach (var property in logEvent.Properties) { WriteJsonProperty(property.Key, property.Value, ref precedingDelimiter, output); } output.Write("}"); } var tokensWithFormat = logEvent.MessageTemplate.Tokens .OfType<PropertyToken>() .Where(pt => pt.Format != null) .GroupBy(pt => pt.PropertyName) .ToArray(); if (tokensWithFormat.Length != 0) { output.Write(",\"Renderings\":{"); var rdelim = ""; foreach (var ptoken in tokensWithFormat) { output.Write(rdelim); rdelim = ","; output.Write("\""); output.Write(ptoken.Key); output.Write("\":["); var fdelim = ""; foreach (var format in ptoken) { output.Write(fdelim); fdelim = ","; output.Write("{"); var eldelim = ""; WriteJsonProperty("Format", format.Format, ref eldelim, output); var sw = new StringWriter(); format.Render(logEvent.Properties, sw); WriteJsonProperty("Rendering", sw.ToString(), ref eldelim, output); output.Write("}"); } output.Write("]"); } output.Write("}"); } if (!_omitEnclosingObject) { output.Write("}"); output.Write(_closingDelimiter); } }
private string RenderLogEvent(LogEvent logEvent) { var logMessage = string.Format("{0}{1}{1}{1}{2}", logEvent.RenderMessage(_formatProvider), Environment.NewLine, logEvent.Exception != null ? logEvent.Exception.ToString() : string.Empty) .Replace('|', '!'); var loggerName = logEvent.Properties.ContainsKey("SourceContext") ? logEvent.Properties["SourceContext"].ToString().Trim(' ', '"') : "NoName"; var message = string.Format( "{0}|TcpAppender|{3}|{1}|1|{2}|{4}|LOG_END|\n", ++_messageCount, GetLevel(logEvent.Level), loggerName, logEvent.Timestamp.ToString("d MMM yyyy HH:mm:ss,fff"), logMessage); return message; }
public void Emit(LogEvent logEvent) { Debug.WriteLine(logEvent.RenderMessage()); }
public void Emit(LogEvent logEvent) { Captures.Add(logEvent.RenderMessage()); }
public static string EventToJson(LogEvent logEvent) { if (logEvent == null) { throw new ArgumentNullException(nameof(logEvent)); } var payload = new Dictionary<string, object>(); try { foreach (var kvp in logEvent.Properties) { var safeKey = kvp.Key.Replace(" ", "").Replace(":", "").Replace("-", "").Replace("_", ""); int dummy; if (int.TryParse(kvp.Key, out dummy)) continue; var simpleValue = SerilogPropertyFormatter.Simplify(kvp.Value); payload[safeKey] = simpleValue; } payload["Level"] = logEvent.Level.ToString(); payload["@timestamp"] = logEvent.Timestamp; var message = logEvent.RenderMessage(); var messageBytes = Encoding.UTF8.GetBytes(message); if (messageBytes.Length > MAX_TERM_BYTES) { var truncated = messageBytes.Length - MAX_TERM_BYTES; var ending = $"[truncated {truncated}]"; var subLength = MAX_TERM_BYTES - ending.Length; if (subLength > 0) { message = message.Substring(0, subLength) + ending; payload["@truncated"] = truncated; } } payload["Message"] = message; if (logEvent.Exception != null) { payload["Exception"] = logEvent.Exception.ToString(); var stackTrace = logEvent.Exception.StackTrace; if (stackTrace != null) { stackTrace = StackTraceFilterRegexp.Replace(stackTrace, string.Empty); payload["exc_stacktrace_hash"] = GetMurmur3HashString(stackTrace); } } var result = JsonConvert.SerializeObject(payload, new JsonSerializerSettings { ReferenceLoopHandling = ReferenceLoopHandling.Ignore }); return result; } catch (Exception ex) { Trace.WriteLine($"Error extracting json from logEvent {ex}"); } return null; }
public void Emit(LogEvent logEvent) { var loggerName = "Default"; LogEventPropertyValue sourceContext; if (logEvent.Properties.TryGetValue(Constants.SourceContextPropertyName, out sourceContext)) { var sv = sourceContext as ScalarValue; if (sv?.Value is string) { loggerName = (string) sv.Value; } } var level = MapLogLevel(logEvent); var message = logEvent.RenderMessage(_formatProvider); var exception = logEvent.Exception; var nlogEvent = new LogEventInfo(level, loggerName, message) { Exception = exception }; foreach (var property in logEvent.Properties) { var sv = property.Value as ScalarValue; var format = (sv?.Value is string) ? "l" : null; nlogEvent.Properties[property.Key] = property.Value.ToString(format, null); } var logger = LogManager.GetLogger(loggerName); logger.Log(nlogEvent); }