| 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);
}
