Basic format support

Author: nblumhardt

README.md

@@ -1 +1,60 @@
-# serilog-expressions
+# _Serilog.Expressions_
+
+A mini-language for filtering, enriching, and formatting Serilog 
+events, ideal for embedding in JSON or XML configuration.
+
+## Getting started
+
+Install the package from NuGet:
+
+```shell
+dotnet add package Serilog.Expressions
+```
+
+The package adds extension methods to Serilog's `Filter` and 
+`Enrich` configuration objects, along with an `OutputTemplate`
+type that's compatible with Serilog sinks accepting an
+`ITextFormatter`.
+
+### Filtering
+
+_Serilog.Expressions_ adds `ByExcluding()` and `ByIncludingOnly()` 
+overloads to the `Filter` configuration object that accept filter
+expressions:
+
+```csharp
+Log.Logger = new LoggerConfiguration()
+    .Filter.ByExcluding("RequestPath like '/health%'")
+    .CreateLogger();
+```
+
+Events with a `RequestPath` property that matches the expression
+will be excluded by the filter.
+
+In [`appSettings.json` 
+configuration](https://github.com/serilog/serilog-settings-configuration) 
+this is written as:
+
+```json
+{
+  "Serilog": {
+    "Using": ["Serilog.Expressions"],
+    "Filter": [
+      {
+        "Name": "ByExcluding",
+        "Args": {
+          "expression": "RequestPath like '/health%'"
+        }
+      }
+    ]
+  }
+}
+```
+
+### Enriching
+
+### Formatting
+
+## Language reference
+
+

example/Sample/Program.cs

@@ -17,12 +17,12 @@ public static void Main()
             using var log = new LoggerConfiguration()
                 .Enrich.WithProperty("AppId", 10)
                 .Enrich.WithComputed("FirstItem", "Items[0]")
-                .Enrich.WithComputed("SourceContext", "coalesce(substring(SourceContext, lastindexof(SourceContext, '.') + 1), SourceContext, '<no source>')")
+                .Enrich.WithComputed("SourceContext", "coalesce(Substring(SourceContext, LastIndexOf(SourceContext, '.') + 1), SourceContext, '<no source>')")
                 .Filter.ByIncludingOnly(expr)
                 .WriteTo.Console(outputTemplate:
                     "[{Timestamp:HH:mm:ss} {Level:u3} ({SourceContext})] {Message:lj} (first item is {FirstItem}){NewLine}{Exception}")
                 .WriteTo.Console(new OutputTemplate(
-                    "[{@t} {@l} ({SourceContext})] {@m} (first item is {Items[0]})\n{@x}"))
+                    "[{@t:HH:mm:ss} {@l:u3} ({SourceContext})] {@m} (first item is {Items[0]})\n{@x}"))
                     .CreateLogger();
 
             log.ForContext<Program>().Information("Cart contains {@Items}", new[] { "Tea", "Coffee" });

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

@@ -3,6 +3,7 @@
 using Serilog.Events;
 using Serilog.Expressions;
 using Serilog.Formatting.Json;
+using Serilog.Templates.Rendering;
 
 namespace Serilog.Templates.Compilation
 {
@@ -30,7 +31,10 @@ public override void Evaluate(LogEvent logEvent, TextWriter output, IFormatProvi
                 if (scalar.Value is null)
                     return; // Null is empty
 
-                if (scalar.Value is IFormattable fmt)
+                if (scalar.Value is LogEventLevel level)
+                    // This would be better implemented using CompiledLevelToken : CompiledTemplate.
+                    output.Write(LevelRenderer.GetLevelMoniker(level, _format));
+                else if (scalar.Value is IFormattable fmt)
                     output.Write(fmt.ToString(_format, formatProvider));
                 else
                     output.Write(scalar.Value.ToString());

src/Serilog.Expressions/Templates/Parsing/TemplateParser.cs

@@ -36,20 +36,44 @@ public static Template Parse(string template)
                     }
                     else
                     {
+                        // A lot of TODOs, here; exceptions thrown instead of error returns; positions of errors not 
+                        // reported
+                        
                         // Not reporting line/column
                         var tokens = Tokenizer.GreedyTokenize(new TextSpan(template, new Position(i, 0, 0), template.Length - i));
                         // Dropping error info; may return a zero-length parse
                         var expr = ExpressionTokenParsers.TryPartialParse(tokens);
-                        // Throw on error; no format parsing
-                        elements.Add(new FormattedExpression(expr.Value, null));
+                        if (!expr.HasValue)
+                            throw new ArgumentException($"Invalid expression, {expr.FormatErrorMessageFragment()}.");
+                        
                         if (expr.Remainder.Position == tokens.Count())
                             i = tokens.Last().Position.Absolute + tokens.Last().Span.Length;
                         else
                             i = tokens.ElementAt(i).Position.Absolute;
 
+                        if (i == template.Length)
+                            throw new ArgumentException("Un-closed hole, `}` expected.");
+
+                        string format = null;
+                        if (template[i] == ':')
+                        {
+                            i++;
+                            
+                            var formatBuilder = new StringBuilder();
+                            while (i < template.Length && template[i] != '}')
+                            {
+                                formatBuilder.Append(template[i]);
+                                i++;
+                            }
+
+                            format = formatBuilder.ToString();
+                        }
+                        
                         if (i == template.Length || template[i] != '}')
                             throw new ArgumentException("Un-closed hole, `}` expected.");
                         i++;
+                        
+                        elements.Add(new FormattedExpression(expr.Value, format));
                     }
                 }
                 else if (ch == '}')

src/Serilog.Expressions/Templates/Rendering/Casing.cs

@@ -0,0 +1,39 @@
+// Copyright Serilog Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+namespace Serilog.Templates.Rendering
+{
+    static class Casing
+    {
+        /// <summary>
+        /// Apply upper or lower casing to <paramref name="value"/> when <paramref name="format"/> is provided.
+        /// Returns <paramref name="value"/> when no or invalid format provided.
+        /// </summary>
+        /// <param name="value">Provided string for formatting.</param>
+        /// <param name="format">Format string.</param>
+        /// <returns>The provided <paramref name="value"/> with formatting applied.</returns>
+        public static string Format(string value, string format = null)
+        {
+            switch (format)
+            {
+                case "u":
+                    return value.ToUpperInvariant();
+                case "w":
+                    return value.ToLowerInvariant();
+                default:
+                    return value;
+            }
+        }
+    }
+}

src/Serilog.Expressions/Templates/Rendering/LevelRenderer.cs

@@ -0,0 +1,102 @@
+// Copyright 2017 Serilog Contributors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using Serilog.Events;
+
+namespace Serilog.Templates.Rendering
+{
+    /// <summary>
+    /// Implements the {Level} element.
+    /// can now have a fixed width applied to it, as well as casing rules.
+    /// Width is set through formats like "u3" (uppercase three chars),
+    /// "w1" (one lowercase char), or "t4" (title case four chars).
+    /// </summary>
+    static class LevelRenderer
+    {
+        static readonly string[][] TitleCaseLevelMap =
+        {
+            new[] { "V", "Vb", "Vrb", "Verb" },
+            new[] { "D", "De", "Dbg", "Dbug" },
+            new[] { "I", "In", "Inf", "Info" },
+            new[] { "W", "Wn", "Wrn", "Warn" },
+            new[] { "E", "Er", "Err", "Eror" },
+            new[] { "F", "Fa", "Ftl", "Fatl" },
+        };
+
+        static readonly string[][] LowercaseLevelMap =
+        {
+            new[] { "v", "vb", "vrb", "verb" },
+            new[] { "d", "de", "dbg", "dbug" },
+            new[] { "i", "in", "inf", "info" },
+            new[] { "w", "wn", "wrn", "warn" },
+            new[] { "e", "er", "err", "eror" },
+            new[] { "f", "fa", "ftl", "fatl" },
+        };
+
+        static readonly string[][] UppercaseLevelMap =
+        {
+            new[] { "V", "VB", "VRB", "VERB" },
+            new[] { "D", "DE", "DBG", "DBUG" },
+            new[] { "I", "IN", "INF", "INFO" },
+            new[] { "W", "WN", "WRN", "WARN" },
+            new[] { "E", "ER", "ERR", "EROR" },
+            new[] { "F", "FA", "FTL", "FATL" },
+        };
+
+        public static string GetLevelMoniker(LogEventLevel value, string format)
+        {
+            if (format == null)
+                return value.ToString();
+            
+            if (format.Length != 2 && format.Length != 3)
+                return Casing.Format(value.ToString(), format);
+
+            // Using int.Parse() here requires allocating a string to exclude the first character prefix.
+            // Junk like "wxy" will be accepted but produce benign results.
+            var width = format[1] - '0';
+            if (format.Length == 3)
+            {
+                width *= 10;
+                width += format[2] - '0';
+            }
+
+            if (width < 1)
+                return string.Empty;
+
+            if (width > 4)
+            {
+                var stringValue = value.ToString();
+                if (stringValue.Length > width)
+                    stringValue = stringValue.Substring(0, width);
+                return Casing.Format(stringValue);
+            }
+
+            var index = (int)value;
+            if (index >= 0 && index <= (int)LogEventLevel.Fatal)
+            {
+                switch (format[0])
+                {
+                    case 'w':
+                        return LowercaseLevelMap[index][width - 1];
+                    case 'u':
+                        return UppercaseLevelMap[index][width - 1];
+                    case 't':
+                        return TitleCaseLevelMap[index][width - 1];
+                }
+            }
+
+            return Casing.Format(value.ToString(), format);
+        }
+    }
+}