Merge pull request #170 from dpvreony/logging

feature: migrate logging helper from whipstaff + foundatio

Author: dpvreony

src/Directory.build.targets

@@ -1,4 +1,10 @@
 <Project>
+  <PropertyGroup Condition="$(TargetFramework.StartsWith('netstandard'))">
+    <DefineConstants>$(DefineConstants);NETSTANDARD;PORTABLE;ARGUMENT_NULL_EXCEPTION_SHIM</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition="$(TargetFramework.StartsWith('netstandard2'))">
+    <DefineConstants>$(DefineConstants);CALLER_ARGUMENT_EXPRESSION_SHIM;IS_EXTERNAL_INIT_SHIM</DefineConstants>
+  </PropertyGroup>
   <PropertyGroup Condition="$(TargetFramework.StartsWith('net4'))">
     <DefineConstants>$(DefineConstants);NET_45;XAML</DefineConstants>
   </PropertyGroup>

src/NetTestRegimentation.XUnit/Logging/LogEntry.cs

@@ -0,0 +1,126 @@
+// Copyright (c) 2019 dpvreony and Contributors. All rights reserved.
+// This file is licensed to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Logging;
+
+namespace NetTestRegimentation.XUnit.Logging
+{
+    /// <summary>
+    /// Represents a log entry.
+    /// </summary>
+    public sealed class LogEntry
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LogEntry"/> class.
+        /// </summary>
+        /// <param name="date">The date and time of the log entry.</param>
+        /// <param name="categoryName">The category name of the log entry.</param>
+        /// <param name="logLevel">The log level of the log entry.</param>
+        /// <param name="state">The state of the log entry.</param>
+        /// <param name="formatter">The formatter of the log entry.</param>
+        public LogEntry(DateTimeOffset date, string categoryName, LogLevel logLevel, object state, Func<object, Exception?, string> formatter)
+        {
+            Date = date;
+            CategoryName = categoryName;
+            LogLevel = logLevel;
+            State = state;
+            Formatter = formatter;
+        }
+
+        /// <summary>
+        /// Gets or sets the date and time of the log entry.
+        /// </summary>
+        public DateTimeOffset Date { get; set; }
+
+        /// <summary>
+        /// Gets or sets the category name of the log entry.
+        /// </summary>
+        public string CategoryName { get; set; }
+
+        /// <summary>
+        /// Gets or sets the log level of the log entry.
+        /// </summary>
+        public LogLevel LogLevel { get; set; }
+
+        /// <summary>
+        /// Gets or sets the scopes of the log entry.
+        /// </summary>
+#pragma warning disable CA1819 // Properties should not return arrays
+        public object[]? Scopes { get; set; }
+#pragma warning restore CA1819 // Properties should not return arrays
+
+        /// <summary>
+        /// Gets or sets the event id of the log entry.
+        /// </summary>
+        public EventId? EventId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the state of the log entry.
+        /// </summary>
+        public object State { get; set; }
+
+        /// <summary>
+        /// Gets or sets the exception of the log entry.
+        /// </summary>
+        public Exception? Exception { get; set; }
+
+        /// <summary>
+        /// Gets or sets the formatter of the log entry.
+        /// </summary>
+        public Func<object, Exception?, string> Formatter { get; set; }
+
+        /// <summary>
+        /// Gets the properties of the log entry.
+        /// </summary>
+        public IDictionary<string, object> Properties { get; } = new Dictionary<string, object>();
+
+        /// <summary>
+        /// Gets the message of the log entry.
+        /// </summary>
+        public string Message => Formatter(State, Exception);
+
+        /// <summary>Returns a string that represents the current object.</summary>
+        /// <returns>A string that represents the current object.</returns>
+        public override string ToString()
+        {
+#pragma warning disable CA1305 // Specify IFormatProvider
+#pragma warning disable CA1304 // Specify CultureInfo
+#pragma warning disable CA1311 // Specify a culture or use an invariant version
+            return string.Concat(string.Empty, Date.ToString("mm:ss.fff"), " ", LogLevel.ToString().Substring(0, 1).ToUpper(), ": ", Message, " - ", CategoryName);
+#pragma warning restore CA1311 // Specify a culture or use an invariant version
+#pragma warning restore CA1304 // Specify CultureInfo
+#pragma warning restore CA1305 // Specify IFormatProvider
+        }
+
+        /// <summary>
+        /// Returns a string that represents the current object.
+        /// </summary>
+        /// <param name="useFullCategory">
+        /// Whether to use the full category name or just the last part.
+        /// </param>
+        /// <returns>A string that represents the current object.</returns>
+        public string ToString(bool useFullCategory)
+        {
+            string category = CategoryName;
+            if (!useFullCategory)
+            {
+                int lastDot = category.LastIndexOf('.');
+                if (lastDot >= 0)
+                {
+                    category = category.Substring(lastDot + 1);
+                }
+            }
+
+#pragma warning disable CA1305 // Specify IFormatProvider
+#pragma warning disable CA1304 // Specify CultureInfo
+#pragma warning disable CA1311 // Specify a culture or use an invariant version
+            return string.Concat(string.Empty, Date.ToString("mm:ss.fff"), " ", LogLevel.ToString().Substring(0, 1).ToUpper(), ": ", Message, " - ", category);
+#pragma warning restore CA1311 // Specify a culture or use an invariant version
+#pragma warning restore CA1304 // Specify CultureInfo
+#pragma warning restore CA1305 // Specify IFormatProvider
+        }
+    }
+}

src/NetTestRegimentation.XUnit/Logging/TestLogger.cs

@@ -0,0 +1,202 @@
+// Copyright (c) 2019 dpvreony and Contributors. All rights reserved.
+// This file is licensed to you under the MIT license.
+// See the LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Microsoft.Extensions.Logging;
+using Xunit;
+
+namespace NetTestRegimentation.XUnit.Logging
+{
+    /// <summary>
+    /// XUnit Test Logger Factory.
+    /// </summary>
+    public sealed class TestLogger : ILoggerFactory
+    {
+        private readonly Dictionary<string, LogLevel> _logLevels = new();
+        private readonly Queue<LogEntry> _logEntries = new();
+        private int _logEntriesWritten;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TestLogger"/> class.
+        /// </summary>
+        /// <param name="configure">Action to invoke when configuring logging options.</param>
+        public TestLogger(Action<TestLoggerOptions>? configure = null)
+        {
+            Options = new TestLoggerOptions();
+            configure?.Invoke(Options);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TestLogger"/> class.
+        /// </summary>
+        /// <param name="output">XUnit output helper.</param>
+        /// <param name="configure">Action to run when configuring logging options.</param>
+        public TestLogger(ITestOutputHelper output, Action<TestLoggerOptions>? configure = null)
+        {
+            Options = new TestLoggerOptions
+            {
+                WriteLogEntryFunc = logEntry =>
+                {
+                    output.WriteLine(logEntry.ToString(false));
+                }
+            };
+
+            configure?.Invoke(Options);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TestLogger"/> class.
+        /// </summary>
+        /// <param name="options">Settings for the logging configuration.</param>
+        public TestLogger(TestLoggerOptions options)
+        {
+            Options = options ?? new TestLoggerOptions();
+        }
+
+        /// <summary>
+        /// Gets the options.
+        /// </summary>
+        public TestLoggerOptions Options { get; }
+
+        /// <summary>
+        /// Gets or sets the default minimum log level.
+        /// </summary>
+        public LogLevel DefaultMinimumLevel
+        {
+            get => Options.DefaultMinimumLevel;
+            set => Options.DefaultMinimumLevel = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum log entries to store.
+        /// </summary>
+        public int MaxLogEntriesToStore
+        {
+            get => Options.MaxLogEntriesToStore;
+            set => Options.MaxLogEntriesToStore = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum log entries to write.
+        /// </summary>
+        public int MaxLogEntriesToWrite
+        {
+            get => Options.MaxLogEntriesToWrite;
+            set => Options.MaxLogEntriesToWrite = value;
+        }
+
+        /// <summary>
+        /// Gets the log entries.
+        /// </summary>
+        public IReadOnlyList<LogEntry> LogEntries
+        {
+            get
+            {
+                lock (_logEntries)
+                {
+                    return _logEntries.ToArray();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Resets the log entries.
+        /// </summary>
+        public void Reset()
+        {
+            lock (_logEntries)
+            {
+                _logEntries.Clear();
+                _logLevels.Clear();
+                _ = Interlocked.Exchange(ref _logEntriesWritten, 0);
+            }
+        }
+
+        /// <inheritdoc/>
+        public ILogger CreateLogger(string categoryName)
+        {
+            return new TestLoggerLogger(categoryName, this);
+        }
+
+        /// <inheritdoc/>
+        public void AddProvider(ILoggerProvider provider)
+        {
+        }
+
+        /// <summary>
+        /// Checks if logging is enabled for the category at a specific log level.
+        /// </summary>
+        /// <param name="category">The category to check.</param>
+        /// <param name="logLevel">The log level to check.</param>
+        /// <returns>Whether the log level is enabled.</returns>
+        public bool IsEnabled(string category, LogLevel logLevel)
+        {
+            if (_logLevels.TryGetValue(category, out var categoryLevel))
+            {
+                return logLevel >= categoryLevel;
+            }
+
+            return logLevel >= Options.DefaultMinimumLevel;
+        }
+
+        /// <summary>
+        /// Sets the log level for a category.
+        /// </summary>
+        /// <param name="category">Category to set.</param>
+        /// <param name="minLogLevel">LoggerFactory level to set.</param>
+        public void SetLogLevel(string category, LogLevel minLogLevel)
+        {
+            _logLevels[category] = minLogLevel;
+        }
+
+        /// <summary>
+        /// Sets the log level for a category based on the type.
+        /// </summary>
+        /// <typeparam name="T">The type to base the category off.</typeparam>
+        /// <param name="minLogLevel">LoggerFactory level to set.</param>
+        public void SetLogLevel<T>(LogLevel minLogLevel)
+        {
+            SetLogLevel(nameof(T), minLogLevel);
+        }
+
+        /// <inheritdoc/>
+        public void Dispose()
+        {
+        }
+
+        internal void AddLogEntry(LogEntry logEntry)
+        {
+            lock (_logEntries)
+            {
+                _logEntries.Enqueue(logEntry);
+
+                if (_logEntries.Count > Options.MaxLogEntriesToStore)
+                {
+                    _ = _logEntries.Dequeue();
+                }
+            }
+
+            if (Options.WriteLogEntryFunc == null || _logEntriesWritten >= Options.MaxLogEntriesToWrite)
+            {
+                return;
+            }
+
+#pragma warning disable CA1031 // Do not catch general exception types
+#pragma warning disable RCS1075 // Avoid empty catch clause that catches System.Exception
+            try
+            {
+                Options.WriteLogEntry(logEntry);
+                _ = Interlocked.Increment(ref _logEntriesWritten);
+            }
+            catch (Exception)
+            {
+                // ignored
+            }
+#pragma warning restore RCS1075 // Avoid empty catch clause that catches System.Exception
+#pragma warning restore CA1031 // Do not catch general exception types
+        }
+    }
+}