feat(logging): add structured json logs by default on production

This closes #12. The structured logs are turned on
by default when compiling in release mode. To disable
the structured json logs, use the `--no-structured-logs`
flag when running the operator.

Author: Christoph Bühler

src/KubeOps/Operator/Commands/RunOperator.cs

@@ -19,6 +19,11 @@ public RunOperator(IHost host)
             _host = host;
         }
 
+        [Option(
+            KubernetesOperator.NoStructuredLogs,
+            Description = "If set, the normal .net logging output appears instead of structured json output.")]
+        public bool NoStructuredLogs { get; set; }
+
         public Task OnExecuteAsync() => _host.RunAsync();
     }
 }

src/KubeOps/Operator/KubernetesOperator.cs

@@ -1,15 +1,18 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using k8s;
 using KubeOps.Operator.Client;
 using KubeOps.Operator.Commands;
 using KubeOps.Operator.DependencyInjection;
+using KubeOps.Operator.Logging;
 using KubeOps.Operator.Serialization;
 using McMaster.Extensions.CommandLineUtils;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Serialization;
@@ -19,6 +22,7 @@ namespace KubeOps.Operator
 {
     public sealed class KubernetesOperator
     {
+        internal const string NoStructuredLogs = "--no-structured-logs";
         private const string DefaultOperatorName = "KubernetesOperator";
         private readonly OperatorSettings _operatorSettings;
 
@@ -47,6 +51,28 @@ public Task<int> Run(string[] args)
             ConfigureRequiredServices();
 
             var app = new CommandLineApplication<RunOperator>();
+
+            _builder.ConfigureLogging(builder =>
+            {
+                builder.ClearProviders();
+#if DEBUG
+                builder.AddConsole(options => options.TimestampFormat = @"[hh:mm:ss] ");
+#else
+                if (args.Contains(NoStructuredLogs))
+                {
+                    builder.AddConsole(options =>
+                    {
+                        options.TimestampFormat = @"[dd.MM.yyyy - hh:mm:ss] ";
+                        options.DisableColors = true;
+                    });
+                }
+                else
+                {
+                    builder.AddStructuredConsole();
+                }
+#endif
+            });
+
             var host = _builder.Build();
 
             app

src/KubeOps/Operator/Logging/LoggingBuilderExtensions.cs

@@ -0,0 +1,20 @@
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Configuration;
+
+namespace KubeOps.Operator.Logging
+{
+    public static class LoggingBuilderExtensions
+    {
+        public static ILoggingBuilder AddStructuredConsole(this ILoggingBuilder builder)
+        {
+            builder.AddConfiguration();
+
+            builder.Services.TryAddEnumerable(ServiceDescriptor
+                .Singleton<ILoggerProvider, StructuredConsoleLoggerProvider>());
+
+            return builder;
+        }
+    }
+}

src/KubeOps/Operator/Logging/LoggingNullScope.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace KubeOps.Operator.Logging
+{
+    internal class LoggingNullScope : IDisposable
+    {
+        public void Dispose()
+        {
+        }
+    }
+}

src/KubeOps/Operator/Logging/StructuredConsoleLogger.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+
+namespace KubeOps.Operator.Logging
+{
+    internal class StructuredConsoleLogger : ILogger
+    {
+        private const string OriginalFormat = "{OriginalFormat}";
+        private readonly string _category;
+        private readonly JsonSerializerSettings _jsonSettings;
+
+        public StructuredConsoleLogger(string category, JsonSerializerSettings jsonSettings)
+        {
+            _category = category;
+            _jsonSettings = jsonSettings;
+        }
+
+        public IDisposable BeginScope<TState>(TState state) => new LoggingNullScope();
+
+        public bool IsEnabled(LogLevel logLevel) => logLevel != LogLevel.None;
+
+        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        {
+            var message = new LogMessage
+            {
+                Category = _category,
+                Message = formatter(state, exception),
+                Timestamp = DateTime.UtcNow,
+            };
+
+            if (state is IReadOnlyList<KeyValuePair<string, object>> parameters)
+            {
+                message.Parameters = new Dictionary<string, object>();
+                foreach (var (key, value) in parameters.Where(pair => pair.Key != OriginalFormat))
+                {
+                    message.Parameters.Add(key, value);
+                }
+            }
+
+            if (exception != null)
+            {
+                message.ExceptionMessage = exception.Message;
+            }
+
+            Console.WriteLine(JsonConvert.SerializeObject(message, _jsonSettings));
+        }
+
+        private struct LogMessage
+        {
+            public string Category { get; set; }
+
+            public DateTime Timestamp { get; set; }
+
+            public string Message { get; set; }
+
+            public string ExceptionMessage { get; set; }
+
+            public IDictionary<string, object> Parameters { get; set; }
+        }
+    }
+}

src/KubeOps/Operator/Logging/StructuredConsoleLoggerProvider.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+
+namespace KubeOps.Operator.Logging
+{
+    internal class StructuredConsoleLoggerProvider : ILoggerProvider
+    {
+        private readonly JsonSerializerSettings _jsonSettings;
+
+        private readonly IDictionary<string, StructuredConsoleLogger> _loggers =
+            new ConcurrentDictionary<string, StructuredConsoleLogger>();
+
+        public StructuredConsoleLoggerProvider(JsonSerializerSettings jsonSettings)
+        {
+            _jsonSettings = jsonSettings;
+            _jsonSettings.NullValueHandling = NullValueHandling.Ignore;
+        }
+
+        public void Dispose()
+        {
+        }
+
+        public ILogger CreateLogger(string categoryName)
+        {
+            if (!_loggers.ContainsKey(categoryName))
+            {
+                _loggers[categoryName] = new StructuredConsoleLogger(categoryName, _jsonSettings);
+            }
+
+            return _loggers[categoryName];
+        }
+    }
+}