Add files missing from the last commit

Author: nblumhardt

serilog-formatting-compact.sln.DotSettings

@@ -0,0 +1,2 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ForCanBeConvertedToForeach/@EntryIndexedValue">DO_NOT_SHOW</s:String></wpf:ResourceDictionary>

src/Serilog.Formatting.Compact/Formatting/Compact/CompactJsonFormatter.cs

@@ -18,6 +18,7 @@
 using Serilog.Events;
 using Serilog.Formatting.Json;
 using Serilog.Parsing;
+using Serilog.Formatting.Compact.Tests.Support;
 
 namespace Serilog.Formatting.Compact
 {

src/Serilog.Formatting.Compact/Formatting/Compact/EventIdHash.cs

@@ -0,0 +1,52 @@
+// Copyright 2016 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 System;
+
+namespace Serilog.Formatting.Compact
+{
+    /// <summary>
+    /// Hash functions for message templates. See <see cref="Compute"/>.
+    /// </summary>
+    public static class EventIdHash
+    {
+        /// <summary>
+        /// Compute a 32-bit hash of the provided <paramref name="messageTemplate"/>. The
+        /// resulting hash value can be uses as an event id in lieu of transmitting the
+        /// full template string.
+        /// </summary>
+        /// <param name="messageTemplate">A message template.</param>
+        /// <returns>A 32-bit hash of the template.</returns>
+        public static uint Compute(string messageTemplate)
+        {
+            if (messageTemplate == null) throw new ArgumentNullException(nameof(messageTemplate));
+
+            // Jenkins one-at-a-time https://en.wikipedia.org/wiki/Jenkins_hash_function
+            unchecked
+            {
+                uint hash = 0;
+                for (var i = 0; i < messageTemplate.Length; ++i)
+                {
+                    hash += messageTemplate[i];
+                    hash += (hash << 10);
+                    hash ^= (hash >> 6);
+                }
+                hash += (hash << 3);
+                hash ^= (hash >> 11);
+                hash += (hash << 15);
+                return hash;
+            }
+        }
+    }
+}

src/Serilog.Formatting.Compact/Formatting/Compact/RenderedCompactJsonFormatter.cs

@@ -0,0 +1,104 @@
+// Copyright 2016 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 System;
+using System.IO;
+using Serilog.Events;
+using Serilog.Formatting.Json;
+
+namespace Serilog.Formatting.Compact
+{
+    /// <summary>
+    /// An <see cref="ITextFormatter"/> that writes events in a compact JSON format, for consumption in environments 
+    /// without message template support. Message templates are rendered into text and a hashed event id is included.
+    /// </summary>
+    public class RenderedCompactJsonFormatter : ITextFormatter
+    {
+        readonly JsonValueFormatter _valueFormatter;
+
+        /// <summary>
+        /// Construct a <see cref="CompactJsonFormatter"/>, optionally supplying a formatter for
+        /// <see cref="LogEventPropertyValue"/>s on the event.
+        /// </summary>
+        /// <param name="valueFormatter">A value formatter, or null.</param>
+        public RenderedCompactJsonFormatter(JsonValueFormatter valueFormatter = null)
+        {
+            _valueFormatter = valueFormatter ?? new JsonValueFormatter(typeTagName: "$type");
+        }
+
+        /// <summary>
+        /// Format the log event into the output. Subsequent events will be newline-delimited.
+        /// </summary>
+        /// <param name="logEvent">The event to format.</param>
+        /// <param name="output">The output.</param>
+        public void Format(LogEvent logEvent, TextWriter output)
+        {
+            FormatEvent(logEvent, output, _valueFormatter);
+            output.WriteLine();
+        }
+
+        /// <summary>
+        /// Format the log event into the output.
+        /// </summary>
+        /// <param name="logEvent">The event to format.</param>
+        /// <param name="output">The output.</param>
+        /// <param name="valueFormatter">A value formatter for <see cref="LogEventPropertyValue"/>s on the event.</param>
+        public static void FormatEvent(LogEvent logEvent, TextWriter output, JsonValueFormatter valueFormatter)
+        {
+            if (logEvent == null) throw new ArgumentNullException(nameof(logEvent));
+            if (output == null) throw new ArgumentNullException(nameof(output));
+            if (valueFormatter == null) throw new ArgumentNullException(nameof(valueFormatter));
+
+            output.Write("{\"@t\":\"");
+            output.Write(logEvent.Timestamp.ToString("O"));
+            output.Write("\",\"@m\":");
+            var message = logEvent.MessageTemplate.Render(logEvent.Properties);
+            JsonValueFormatter.WriteQuotedJsonString(message, output);
+            output.Write(",\"@i\":\"");
+            var id = EventIdHash.Compute(logEvent.MessageTemplate.Text);
+            output.Write(id.ToString("x8"));
+            output.Write('"');
+
+            if (logEvent.Level != LogEventLevel.Information)
+            {
+                output.Write(",\"@l\":\"");
+                output.Write(logEvent.Level);
+                output.Write('\"');
+            }
+
+            if (logEvent.Exception != null)
+            {
+                output.Write(",\"@x\":");
+                JsonValueFormatter.WriteQuotedJsonString(logEvent.Exception.ToString(), output);
+            }
+
+            foreach (var property in logEvent.Properties)
+            {
+                var name = property.Key;
+                if (name.Length > 0 && name[0] == '@')
+                {
+                    // Escape first '@' by doubling
+                    name = '@' + name;
+                }
+
+                output.Write(',');
+                JsonValueFormatter.WriteQuotedJsonString(name, output);
+                output.Write(':');
+                valueFormatter.Format(property.Value, output);
+            }
+
+            output.Write('}');
+        }
+    }
+}

test/Serilog.Formatting.Compact.Tests/EventIdHashTests.cs

@@ -0,0 +1,23 @@
+using Xunit;
+
+namespace Serilog.Formatting.Compact.Tests
+{
+    public class EventIdHashTests
+    {
+        [Fact]
+        public void HashingIsConsistent()
+        {
+            var h1 = EventIdHash.Compute("Template 1");
+            var h2 = EventIdHash.Compute("Template 1");
+            Assert.Equal(h1, h2);
+        }
+
+        [Fact]
+        public void DistinctHashesAreComputed()
+        {
+            var h1 = EventIdHash.Compute("Template 1");
+            var h2 = EventIdHash.Compute("Template 2");
+            Assert.NotEqual(h1, h2);
+        }
+    }
+}

test/Serilog.Formatting.Compact.Tests/RenderedCompactJsonFormatterTests.cs

@@ -0,0 +1,79 @@
+using System;
+using Newtonsoft.Json.Linq;
+using Xunit;
+using Serilog.Formatting.Compact.Tests.Support;
+
+
+namespace Serilog.Formatting.Compact.Tests
+{
+    public class RenderedCompactJsonFormatterTests
+    {
+        JObject AssertValidJson(Action<ILogger> act)
+        {
+            return Assertions.AssertValidJson(new RenderedCompactJsonFormatter(), act);
+        }
+
+        [Fact]
+        public void AnEmptyEventIsValidJson()
+        {
+            AssertValidJson(log => log.Information("No properties"));
+        }
+
+        [Fact]
+        public void AMinimalEventIsValidJson()
+        {
+            var jobject = AssertValidJson(log => log.Information("One {Property}", 42));
+
+            JToken m;
+            Assert.True(jobject.TryGetValue("@m", out m));
+            Assert.Equal("One 42", m.ToObject<string>());
+
+            JToken i;
+            Assert.True(jobject.TryGetValue("@i", out i));
+            Assert.Equal(EventIdHash.Compute("One {Property}").ToString("x8"), i.ToObject<string>());
+
+        }
+
+        [Fact]
+        public void MultiplePropertiesAreDelimited()
+        {
+            AssertValidJson(log => log.Information("Property {First} and {Second}", "One", "Two"));
+        }
+
+        [Fact]
+        public void ExceptionsAreFormattedToValidJson()
+        {
+            AssertValidJson(log => log.Information(new DivideByZeroException(), "With exception"));
+        }
+
+        [Fact]
+        public void ExceptionAndPropertiesAreValidJson()
+        {
+            AssertValidJson(log => log.Information(new DivideByZeroException(), "With exception and {Property}", 42));
+        }
+
+        [Fact]
+        public void RenderingsAreValidJson()
+        {
+            AssertValidJson(log => log.Information("One {Rendering:x8}", 42));
+        }
+
+        [Fact]
+        public void MultipleRenderingsAreDelimited()
+        {
+            AssertValidJson(log => log.Information("Rendering {First:x8} and {Second:x8}", 1, 2));
+        }
+
+        [Fact]
+        public void AtPrefixedPropertyNamesAreEscaped()
+        {
+            // Not possible in message templates, but accepted this way
+            var jobject = AssertValidJson(log => log.ForContext("@Mistake", 42)
+                                                    .Information("Hello"));
+
+            JToken val;
+            Assert.True(jobject.TryGetValue("@@Mistake", out val));
+            Assert.Equal(42, val.ToObject<int>());
+        }
+    }
+}

test/Serilog.Formatting.Compact.Tests/Support/Assertions.cs

@@ -0,0 +1,24 @@
+using System;
+using System.IO;
+using Newtonsoft.Json.Linq;
+
+namespace Serilog.Formatting.Compact.Tests.Support
+{
+    static class Assertions
+    {
+        public static JObject AssertValidJson(ITextFormatter formatter, Action<ILogger> act)
+        {
+            var output = new StringWriter();
+            var log = new LoggerConfiguration()
+                .WriteTo.Sink(new TextWriterSink(output, formatter))
+                .CreateLogger();
+
+            act(log);
+
+            var json = output.ToString();
+
+            // Unfortunately this will not detect all JSON formatting issues; better than nothing however.
+            return JObject.Parse(json);
+        }
+    }
+}