public int FormatLiteralValue(ScalarValue scalar, TextWriter output, string format)
{
var value = scalar.Value;
var count = 0;
if (value == null)
{
using (ApplyStyle(output, ConsoleThemeStyle.Null, ref count))
output.Write("null");
return(count);
}
if (value is string str)
{
using (ApplyStyle(output, ConsoleThemeStyle.String, ref count))
JsonValueFormatter.WriteQuotedJsonString(str, output);
return(count);
}
if (value is ValueType)
{
if (value is int || value is uint || value is long || value is ulong ||
value is decimal || value is byte || value is sbyte || value is short ||
value is ushort || value is float || value is double)
{
using (ApplyStyle(output, ConsoleThemeStyle.Number, ref count))
scalar.Render(output, format, _formatProvider);
return(count);
}
if (value is bool b)
{
using (ApplyStyle(output, ConsoleThemeStyle.Boolean, ref count))
output.Write(b);
return(count);
}
if (value is char ch)
{
using (ApplyStyle(output, ConsoleThemeStyle.Scalar, ref count))
{
output.Write('\'');
output.Write(ch);
output.Write('\'');
}
return(count);
}
}
using (ApplyStyle(output, ConsoleThemeStyle.Scalar, ref count))
scalar.Render(output, format, _formatProvider);
return(count);
}
public override void Render(LogEvent logEvent, TextWriter output)
{
// We need access to ScalarValue.Render() to avoid this alloc; just ensures
// that custom format providers are supported properly.
var sv = new ScalarValue(logEvent.Timestamp);
using (_theme.Apply(output, HtmlThemeStyle.SecondaryText))
{
if (_token.Alignment is null)
{
sv.Render(output, _token.Format);
}
else
{
var buffer = new StringWriter();
sv.Render(buffer, _token.Format);
var str = buffer.ToString();
Padding.Apply(output, str, _token.Alignment);
}
}
}
public override void Render(LogEvent logEvent, TokenEmitter emitToken)
{
// We need access to ScalarValue.Render() to avoid this alloc; just ensures
// that custom format providers are supported properly.
var sv = new ScalarValue(logEvent.Timestamp);
var buffer = new StringWriter();
sv.Render(buffer, _token.Format, _formatProvider);
var str = buffer.ToString();
if (_token.Alignment is not null)
{
emitToken(Padding.Apply(str, _token.Alignment));
}
else
{
emitToken(str);
}
}
public static void FormatScalarValue(LogEvent logEvent, TextWriter builder, ScalarValue value, string format, string propertyName)
{
switch (value.Value)
{
case null:
ColorCodeContext.WriteOverridden(builder, logEvent, ColorCode.NullValue, "NULL");
break;
case string strv:
if (string.IsNullOrEmpty(propertyName) || !CustomColoredProperties.Map.TryGetValue(propertyName, out var colorCode))
{
colorCode = ColorCode.StringValue;
}
using (ColorCodeContext.StartOverridden(builder, logEvent, colorCode))
{
builder.Write(strv);
break;
}
case bool bv:
ColorCodeContext.WriteOverridden(builder, logEvent, ColorCode.BooleanValue, bv ? "true" : "false");
break;
case char chv:
ColorCodeContext.WriteOverridden(builder, logEvent, ColorCode.ScalarValue, "\'" + chv.ToString(CultureInfo.InvariantCulture) + "\'");
break;
case sbyte _:
case byte _:
case short _:
case ushort _:
case int _:
case uint _:
case long _:
case ulong _:
using (ColorCodeContext.StartOverridden(builder, logEvent, ColorCode.NumberValue))
{
if (string.IsNullOrEmpty(format))
{
value.Render(builder, "#,0", CultureInfo.InvariantCulture);
}
else
{
value.Render(builder, format, CultureInfo.InvariantCulture);
}
break;
}
case float _:
case double _:
case decimal _:
using (ColorCodeContext.StartOverridden(builder, logEvent, ColorCode.NumberValue))
{
if (string.IsNullOrEmpty(format))
{
value.Render(builder, "#,0.#", CultureInfo.InvariantCulture);
}
else
{
value.Render(builder, format, CultureInfo.InvariantCulture);
}
break;
}
case TimeSpan ts:
using (ColorCodeContext.StartOverridden(builder, logEvent, ColorCode.TimeSpanValue))
{
if (string.IsNullOrEmpty(format))
{
if (ts.Days > 0)
{
value.Render(builder, @"d\.hh\:mm");
}
else if (ts.Hours > 0)
{
value.Render(builder, @"h\:mm\:ss", CultureInfo.InvariantCulture);
}
else if (ts.Minutes > 0)
{
value.Render(builder, @"m\:ss", CultureInfo.InvariantCulture);
}
else if (ts.Seconds > 0)
{
value.Render(builder, @"s\.fff", CultureInfo.InvariantCulture);
}
else
{
value.Render(builder, @"\.fff", CultureInfo.InvariantCulture);
}
}
else
{
value.Render(builder, format, CultureInfo.InvariantCulture);
}
break;
}
case DateTime _:
using (ColorCodeContext.StartOverridden(builder, logEvent, ColorCode.ScalarValue))
{
value.Render(builder, "yyyy.MM.dd HH:mm:ss.fff", CultureInfo.InvariantCulture);
}
break;
case DateTimeOffset _:
using (ColorCodeContext.StartOverridden(builder, logEvent, ColorCode.ScalarValue))
{
value.Render(builder, "yyyy.MM.dd HH:mm:ss.fff zzz", CultureInfo.InvariantCulture);
}
break;
default:
using (ColorCodeContext.StartOverridden(builder, logEvent, ColorCode.ScalarValue))
{
value.Render(builder, format, CultureInfo.InvariantCulture);
}
break;
}
}
/// <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(nameof(logEvent));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
foreach (var token in _outputTemplate.Tokens)
{
if (token is TextToken tt)
{
MessageTemplateRenderer.RenderTextToken(tt, output);
continue;
}
var pt = (PropertyToken)token;
if (pt.PropertyName == OutputProperties.LevelPropertyName)
{
var moniker = LevelOutputFormat.GetLevelMoniker(logEvent.Level, pt.Format);
Padding.Apply(output, moniker, pt.Alignment);
}
else if (pt.PropertyName == OutputProperties.NewLinePropertyName)
{
Padding.Apply(output, Environment.NewLine, pt.Alignment);
}
else if (pt.PropertyName == OutputProperties.ExceptionPropertyName)
{
var exception = logEvent.Exception == null ? "" : logEvent.Exception + Environment.NewLine;
Padding.Apply(output, exception, pt.Alignment);
}
else
{
// In this block, `writer` may be used to buffer output so that
// padding can be applied.
var writer = pt.Alignment.HasValue ? new StringWriter() : output;
if (pt.PropertyName == OutputProperties.MessagePropertyName)
{
MessageTemplateRenderer.Render(logEvent.MessageTemplate, logEvent.Properties, writer, pt.Format, _formatProvider);
}
else if (pt.PropertyName == OutputProperties.TimestampPropertyName)
{
ScalarValue.Render(logEvent.Timestamp, writer, pt.Format, _formatProvider);
}
else if (pt.PropertyName == OutputProperties.PropertiesPropertyName)
{
PropertiesOutputFormat.Render(logEvent.MessageTemplate, logEvent.Properties, _outputTemplate, writer, pt.Format, _formatProvider);
}
else
{
// If a property is missing, don't render anything (message templates render the raw token here).
if (!logEvent.Properties.TryGetValue(pt.PropertyName, out var propertyValue))
{
continue;
}
// If the value is a scalar string, support some additional formats: 'u' for uppercase
// and 'w' for lowercase.
var sv = propertyValue as ScalarValue;
if (sv?.Value is string literalString)
{
var cased = Casing.Format(literalString, pt.Format);
writer.Write(cased);
}
else
{
propertyValue.Render(writer, pt.Format, _formatProvider);
}
}
if (pt.Alignment.HasValue)
{
Padding.Apply(output, ((StringWriter)writer).ToString(), pt.Alignment);
}
}
}
}
public int FormatLiteralValue(ScalarValue scalar, TextWriter output, string format)
{
var value = scalar.Value;
var count = 0;
if (value is null)
{
using (ApplyStyle(output, RichTextBoxThemeStyle.Null, ref count))
{
output.Write("null");
}
return count;
}
if (value is string str)
{
using (ApplyStyle(output, RichTextBoxThemeStyle.String, ref count))
{
var escapedStr = SpecialCharsEscaping.Apply(str, ref count);
if (format != "l")
{
JsonValueFormatter.WriteQuotedJsonString(escapedStr, output);
}
else
{
output.Write(escapedStr);
}
}
return count;
}
if (value is ValueType)
{
if (value is int || value is uint || value is long || value is ulong ||
value is decimal || value is byte || value is sbyte || value is short ||
value is ushort || value is float || value is double)
{
using (ApplyStyle(output, RichTextBoxThemeStyle.Number, ref count))
{
scalar.Render(output, format, _formatProvider);
}
return count;
}
if (value is bool b)
{
using (ApplyStyle(output, RichTextBoxThemeStyle.Boolean, ref count))
{
output.Write(b.ToString(CultureInfo.InvariantCulture));
}
return count;
}
if (value is char ch)
{
using (ApplyStyle(output, RichTextBoxThemeStyle.Scalar, ref count))
{
output.Write('\'');
output.Write(SpecialCharsEscaping.Apply(ch.ToString(), ref count));
output.Write('\'');
}
return count;
}
}
using (ApplyStyle(output, RichTextBoxThemeStyle.Scalar, ref count))
{
scalar.Render(output, format, _formatProvider);
}
return count;
}
/// <inheritdoc cref="IPropertyRenderer"/>
public void Render(ExtendedLogEvent logEvent, TextWriter output)
{
var scalarValue = new ScalarValue(logEvent.LogEvent.Timestamp);
scalarValue.Render(output, this.propertyToken.Format);
}
