Lazy coercion of levels/exceptions

Author: nblumhardt

example/Sample/Program.cs

@@ -1,11 +1,16 @@
-using Serilog;
+using System;
+using Serilog;
+using Serilog.Debugging;
+using Serilog.Templates;
 
 namespace Sample
 {
     public class Program
     {
         public static void Main()
         {
+            SelfLog.Enable(Console.Error);
+            
             const string expr = "@Level = 'Information' and AppId is not null and Items[?] like 'C%'";
 
             using var log = new LoggerConfiguration()
@@ -15,7 +20,9 @@ public static void Main()
                 .Filter.ByIncludingOnly(expr)
                 .WriteTo.Console(outputTemplate:
                     "[{Timestamp:HH:mm:ss} {Level:u3} ({SourceContext})] {Message:lj} (first item is {FirstItem}){NewLine}{Exception}")
-                .CreateLogger();
+                .WriteTo.Console(new OutputTemplate(
+                    "[{@Timestamp} {@Level} ({SourceContext})] {@Message} (first item is {Items[0]})\n{@Exception}"))
+                    .CreateLogger();
 
             log.ForContext<Program>().Information("Cart contains {@Items}", new[] { "Tea", "Coffee" });
             log.Warning("Cart contains {@Items}", new[] { "Tea", "Coffee" });

src/Serilog.Expressions/Expressions/Compilation/Linq/LinqExpressionCompiler.cs

@@ -178,13 +178,13 @@ protected override Expression<CompiledExpression> Transform(AmbientPropertyExpre
             if (px.IsBuiltIn)
             {
                 if (px.PropertyName == BuiltInProperty.Level)
-                    return context => new ScalarValue(context.Level.ToString());
+                    return context => new ScalarValue(context.Level);
 
                 if (px.PropertyName == BuiltInProperty.Message)
                     return context => NormalizeBuiltInProperty(context.RenderMessage(null));
 
                 if (px.PropertyName == BuiltInProperty.Exception)
-                    return context => NormalizeBuiltInProperty(context.Exception == null ? null : context.Exception.ToString());
+                    return context => context.Exception == null ? null : new ScalarValue(context.Exception);
 
                 if (px.PropertyName == BuiltInProperty.Timestamp)
                     return context => new ScalarValue(context.Timestamp);

src/Serilog.Expressions/Expressions/Runtime/Coerce.cs

@@ -45,11 +45,25 @@ public static bool True(LogEventPropertyValue value)
 
         public static bool String(LogEventPropertyValue value, out string str)
         {
-            if (value is ScalarValue sv &&
-                sv.Value is string s)
+            if (value is ScalarValue sv)
             {
-                str = s;
-                return true;
+                if (sv.Value is string s)
+                {
+                    str = s;
+                    return true;
+                }
+                
+                if (sv.Value is Exception ex)
+                {
+                    str = ex.ToString();
+                    return true;
+                }
+
+                if (sv.Value?.GetType().IsEnum ?? false)
+                {
+                    str = sv.Value.ToString();
+                    return true;
+                }
             }
 
             str = default;

src/Serilog.Expressions/Expressions/Runtime/RuntimeOperators.cs

@@ -137,6 +137,10 @@ static bool UnboxedEqualHelper(LogEventPropertyValue left, LogEventPropertyValue
                 Coerce.Numeric(right, out var r))
                 return l == r;
 
+            if (Coerce.String(left, out var ls) &&
+                Coerce.String(right, out var rs))
+                return ls == rs;
+            
             if (left is ScalarValue sl &&
                 right is ScalarValue sr)
                 return sl.Value?.Equals(sr.Value) ?? sr.Value == null;

src/Serilog.Expressions/Templates/Compilation/CompiledFormattedExpression.cs

@@ -2,11 +2,14 @@
 using System.IO;
 using Serilog.Events;
 using Serilog.Expressions;
+using Serilog.Formatting.Json;
 
 namespace Serilog.Templates.Compilation
 {
     class CompiledFormattedExpression : CompiledTemplate
     {
+        static readonly JsonValueFormatter JsonFormatter = new JsonValueFormatter("$type");
+        
         readonly CompiledExpression _expression;
         readonly string _format;
 
@@ -19,7 +22,23 @@ public CompiledFormattedExpression(CompiledExpression expression, string format)
         public override void Evaluate(LogEvent logEvent, TextWriter output, IFormatProvider formatProvider)
         {
             var value = _expression(logEvent);
-            value?.Render(output, _format, formatProvider);
+            if (value == null)
+                return; // Undefined is empty
+            
+            if (value is ScalarValue scalar)
+            {
+                if (scalar.Value is null)
+                    return; // Null is empty
+
+                if (scalar.Value is IFormattable fmt)
+                    output.Write(fmt.ToString(_format, formatProvider));
+                else
+                    output.Write(scalar.Value.ToString());
+            }
+            else
+            {
+                JsonFormatter.Format(value, output);
+            }
         }
     }
 }