private static object ToRawValue(LogEventPropertyValue logEventValue)
{
// Special-case a few types of LogEventPropertyValue that allow us to maintain better type fidelity.
// For everything else take the default string rendering as the data.
ScalarValue scalarValue = logEventValue as ScalarValue;
if (scalarValue != null)
{
return(scalarValue.Value);
}
SequenceValue sequenceValue = logEventValue as SequenceValue;
if (sequenceValue != null)
{
object[] arrayResult = sequenceValue.Elements.Select(e => ToRawScalar(e)).ToArray();
if (arrayResult.Length == sequenceValue.Elements.Count)
{
// All values extracted successfully, it is a flat array of scalars
return(arrayResult);
}
}
StructureValue structureValue = logEventValue as StructureValue;
if (structureValue != null)
{
IDictionary <string, object> structureResult = new Dictionary <string, object>(structureValue.Properties.Count);
foreach (var property in structureValue.Properties)
{
structureResult[property.Name] = ToRawScalar(property.Value);
}
if (structureResult.Count == structureValue.Properties.Count)
{
if (structureValue.TypeTag != null)
{
structureResult["$type"] = structureValue.TypeTag;
}
return(structureResult);
}
}
DictionaryValue dictionaryValue = logEventValue as DictionaryValue;
if (dictionaryValue != null)
{
IDictionary <string, object> dictionaryResult = dictionaryValue.Elements
.Where(kvPair => kvPair.Key.Value is string)
.ToDictionary(kvPair => (string)kvPair.Key.Value, kvPair => ToRawScalar(kvPair.Value));
if (dictionaryResult.Count == dictionaryValue.Elements.Count)
{
return(dictionaryResult);
}
}
// Fall back to string rendering of the value
return(logEventValue.ToString());
}
private static void AddEventPropertyAsLabel(TextWriter output, string eventPropertyKey, LogEventPropertyValue eventPropertyValue)
{
output.Write(eventPropertyKey);
output.Write("=\\\"");
output.Write(eventPropertyValue.ToString());
output.Write("\\\"");
}
private static object GetPropertyValue(LogEventPropertyValue propertyValue)
{
return(propertyValue switch
{
SequenceValue sequenceValue => sequenceValue.Elements.Select(RenderSequenceValue).ToArray(),
ScalarValue scalarValue => scalarValue.Value,
_ => propertyValue.ToString()
});
/// <summary>
/// All Serilog property values are quoted, which is unnecessary, as we are going to encase them in
/// quotes anyway, to conform to the specification for syslog structured data values - so this
/// removes them and also unescapes any others
/// </summary>
private static string RenderPropertyValue(LogEventPropertyValue propertyValue)
{
// Trim surrounding quotes, and unescape all others
var result = propertyValue
.ToString()
.TrimAndUnescapeQuotes();
// Use a backslash to escape backslashes, double quotes and closing square brackets
return(Regex.Replace(result, @"[\]\\""]", match => $@"\{match}"));
}
protected string GetPropertyValue(LogEventPropertyValue value)
{
var scalar = value as ScalarValue;
if (scalar?.Value != null)
{
return(scalar.Value.ToString());
}
return(value.ToString());
}
private static object ToRawScalar(LogEventPropertyValue value)
{
ScalarValue scalarValue = value as ScalarValue;
if (scalarValue != null)
{
return(scalarValue.Value);
}
return(value.ToString());
}
private object AutoCorrectResponseStatus(LogEventPropertyValue value)
{
var statusCode = value.ToString();
if (statusCode.All(char.IsNumber))
{
return(value);
}
Enum.TryParse <HttpStatusCode>(statusCode, out var result);
return((int)result);
}
static string ValueToString(LogEventPropertyValue property)
{
var scalarValue = property as ScalarValue;
if (scalarValue != null)
{
var valueType = scalarValue.Value.GetType();
if (valueType == typeof(DateTime) || valueType == typeof(DateTimeOffset))
{
return(scalarValue.ToString("yyyy-MM-ddTHH:mm:ss.fffK", CultureInfo.InvariantCulture));
}
}
return(property.ToString().Trim('"'));
}
private static object GetValue(LogEventPropertyValue value, out GraylogPropertyType propType)
{
// as GELF currently only allows string or numeric values, we'll have to convert if type is not matching
if (value == null)
{
propType = GraylogPropertyType.String;
return(string.Empty);
}
if (!(value is ScalarValue scalar))
{
propType = GraylogPropertyType.String;
return(value.ToString());
}
if (scalar.Value == null)
{
propType = GraylogPropertyType.String;
return(value.ToString());
}
propType = GetPropertyType(scalar.Value);
return(propType == GraylogPropertyType.Numeric
? scalar.Value
: scalar.Value.ToString());
}
private static object GetPropertyInternalValue(LogEventPropertyValue propertyValue)
{
switch (propertyValue)
{
case ScalarValue sv: return(GetInternalValue(sv.Value));
case SequenceValue sv: return(sv.Elements.Select(GetPropertyInternalValue).ToArray());
case DictionaryValue dv: return(dv.Elements.Select(kv => new { Key = kv.Key.Value, Value = GetPropertyInternalValue(kv.Value) }).ToDictionary(i => i.Key, i => i.Value));
case StructureValue sv: return(sv.Properties.Select(kv => new { Key = kv.Name, Value = GetPropertyInternalValue(kv.Value) }).ToDictionary(i => i.Key, i => i.Value));
}
return(propertyValue.ToString());
}
public static string ExtractStringRepresentationOfLogEventPropertyValue(
LogEventPropertyValue property)
{
// We don't want to decorate strings we additional
// unnecessary quotes, so we need to extract its value directly
if (property is ScalarValue sv)
{
if (sv.Value is string s)
{
return(s);
}
}
var actualValue = property.ToString();
return(actualValue);
}
public LogEventVM(LogEvent logEvent, IFormatProvider formatProvider)
{
Level = logEvent.Level;
Time = logEvent.Timestamp.ToString("HH:mm:ss.fff");
Message = logEvent.RenderMessage(formatProvider);
Exception = logEvent.Exception?.Message;
LogEventPropertyValue contextValue = null;
if (logEvent.Properties.TryGetValue("SourceContext", out contextValue))
{
SourceContext = contextValue?.ToString().Replace("\"", "");
}
LogEventPropertyValue tokenValue = null;
if (logEvent.Properties.TryGetValue("Token", out tokenValue))
{
Token = tokenValue?.ToString();
}
}
private object ToRawValue(LogEventPropertyValue logEventValue)
{
// Special-case a few types of LogEventPropertyValue that allow us to maintain better type fidelity.
// For everything else take the default string rendering as the data.
ScalarValue scalarValue = logEventValue as ScalarValue;
if (scalarValue != null)
{
return(scalarValue.Value);
}
SequenceValue sequenceValue = logEventValue as SequenceValue;
if (sequenceValue != null)
{
object[] arrayResult = sequenceValue.Elements.OfType <ScalarValue>().Select(e => e.Value).ToArray();
if (arrayResult.Length == sequenceValue.Elements.Count)
{
// All values extracted successfully, it is a flat array of scalars
return(arrayResult);
}
}
DictionaryValue dictionaryValue = logEventValue as DictionaryValue;
if (dictionaryValue != null)
{
IDictionary <string, object> dictionaryResult = dictionaryValue.Elements
.Where(kvPair => kvPair.Key.Value is string && kvPair.Value is ScalarValue)
.ToDictionary(kvPair => (string)kvPair.Key.Value, kvPair => ((ScalarValue)kvPair.Value).Value);
if (dictionaryResult.Count == dictionaryValue.Elements.Count)
{
return(dictionaryResult);
}
}
// Fall back to string rendering of the value
return(logEventValue.ToString());
}
private static Process GetProcess(LogEvent e, bool mapFromCurrentThread)
{
LogEventPropertyValue processNameProp = null;
LogEventPropertyValue processIdProp = null;
LogEventPropertyValue threadIdProp = null;
e.Properties.TryGetValue(SpecialKeys.ProcessName, out processNameProp);
e.Properties.TryGetValue(SpecialKeys.ProcessId, out processIdProp);
e.Properties.TryGetValue(SpecialKeys.ThreadId, out threadIdProp);
if (processNameProp == null &&
processIdProp == null &&
threadIdProp == null &&
!mapFromCurrentThread)
{
return(null);
}
var processName = processNameProp?.ToString();
var processId = processIdProp?.ToString();
var threadId = threadIdProp?.ToString();
var pid = int.TryParse(processId ?? "", out var p)
? p
: (int?)null;
if (!mapFromCurrentThread)
{
return(new Process
{
Title = processName,
Name = processName,
Pid = pid,
Thread = int.TryParse(threadId ?? processId ?? "", out var id)
? new ProcessThread()
{
Id = id
}
: null,
});
private object GetRenderedProperty(LogEventPropertyValue value)
{
switch (value)
{
case SequenceValue sequenceValue:
return(sequenceValue.Elements.Select(GetRenderedSequenceValue).ToArray());
case StructureValue structureValue:
return(structureValue.Properties
.ToDictionary(x => x.Name, x => GetRenderedProperty(x.Value)));
case ScalarValue scalarValue:
switch (scalarValue.Value)
{
case null:
return(null);
case string str:
return(str);
case DateTime dt:
return(dt.ToString("o"));
case DateTimeOffset dt:
return(dt.ToString("o"));
case var numericScalar when numericScalar.GetType().IsNumericType():
return(numericScalar);
case var unknownScalar:
return(string.Format(_options.FormatProvider, "{0}", unknownScalar));
}
default:
return(value.ToString(null, _options.FormatProvider));
}
}
private object GetRenderedSequenceValue(LogEventPropertyValue value) => (value as ScalarValue)?.Value ?? value.ToString(null, _options.FormatProvider);
public static string RemoveNonAlphanumerical(this LogEventPropertyValue initString) => _regex.Replace(initString.ToString(), string.Empty);
/// <summary>
/// Gets the value of the logged property value as a string.
/// </summary>
/// <param name="property">The property to get the value.</param>
public static string ToStringValue(this LogEventPropertyValue property)
{
return(property.ToString().Trim('\"'));
}
