diff --git a/src/PSRule.Types/Runtime/EventId.cs b/src/PSRule.Types/Runtime/EventId.cs
new file mode 100644
index 0000000000..f24cf518bc
--- /dev/null
+++ b/src/PSRule.Types/Runtime/EventId.cs
@@ -0,0 +1,93 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace PSRule.Runtime;
+
+/// <summary>
+/// Identifies a logging event.
+/// The primary identifier is the "Id" property, with the "Name" property providing a short description of this type of event.
+/// </summary>
+public readonly struct EventId : IEquatable<EventId>
+{
+    /// <summary>
+    /// Implicitly creates an EventId from the given <see cref="int"/>.
+    /// </summary>
+    /// <param name="i">The <see cref="int"/> to convert to an EventId.</param>
+    public static implicit operator EventId(int i)
+    {
+        return new EventId(i);
+    }
+
+    /// <summary>
+    /// Checks if two specified <see cref="EventId"/> instances have the same value. They are equal if they have the same Id.
+    /// </summary>
+    /// <param name="left">The first <see cref="EventId"/>.</param>
+    /// <param name="right">The second <see cref="EventId"/>.</param>
+    /// <returns><see langword="true" /> if the objects are equal.</returns>
+    public static bool operator ==(EventId left, EventId right)
+    {
+        return left.Equals(right);
+    }
+
+    /// <summary>
+    /// Checks if two specified <see cref="EventId"/> instances have different values.
+    /// </summary>
+    /// <param name="left">The first <see cref="EventId"/>.</param>
+    /// <param name="right">The second <see cref="EventId"/>.</param>
+    /// <returns><see langword="true" /> if the objects are not equal.</returns>
+    public static bool operator !=(EventId left, EventId right)
+    {
+        return !left.Equals(right);
+    }
+
+    /// <summary>
+    /// Initializes an instance of the <see cref="EventId"/> struct.
+    /// </summary>
+    /// <param name="id">The numeric identifier for this event.</param>
+    /// <param name="name">The name of this event.</param>
+    public EventId(int id, string? name = null)
+    {
+        Id = id;
+        Name = name;
+    }
+
+    /// <summary>
+    /// Gets the numeric identifier for this event.
+    /// </summary>
+    public int Id { get; }
+
+    /// <summary>
+    /// Gets the name of this event.
+    /// </summary>
+    public string? Name { get; }
+
+    /// <inheritdoc />
+    public override string ToString()
+    {
+        return Name ?? Id.ToString();
+    }
+
+    /// <summary>
+    /// Indicates whether the current object is equal to another object of the same type. Two events are equal if they have the same id.
+    /// </summary>
+    /// <param name="other">An object to compare with this object.</param>
+    /// <returns><see langword="true" /> if the current object is equal to the other parameter; otherwise, <see langword="false" />.</returns>
+    public bool Equals(EventId other)
+    {
+        return Id == other.Id;
+    }
+
+    /// <inheritdoc />
+    public override bool Equals(object? obj)
+    {
+        if (obj is null) return false;
+
+        return obj is EventId eventId && Equals(eventId);
+    }
+
+    /// <inheritdoc />
+    public override int GetHashCode()
+    {
+        return Id;
+    }
+}
diff --git a/src/PSRule.Types/Runtime/FormattedLogValues.cs b/src/PSRule.Types/Runtime/FormattedLogValues.cs
new file mode 100644
index 0000000000..6b34b3d155
--- /dev/null
+++ b/src/PSRule.Types/Runtime/FormattedLogValues.cs
@@ -0,0 +1,64 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Collections;
+
+namespace PSRule.Runtime;
+
+/// <summary>
+/// Enable formatted log values in diagnostic messages.
+/// </summary>
+internal readonly struct FormattedLogValues : IReadOnlyList<KeyValuePair<string, object?>>
+{
+    private const string NullFormat = "[null]";
+
+    private readonly object?[]? _Values;
+    private readonly string _OriginalMessage;
+
+    public FormattedLogValues(string? format, params object?[]? values)
+    {
+        _OriginalMessage = format ?? NullFormat;
+        _Values = values;
+    }
+
+    public KeyValuePair<string, object?> this[int index]
+    {
+        get
+        {
+            if (index < 0 || index >= Count) throw new IndexOutOfRangeException(nameof(index));
+
+            if (index == Count - 1)
+            {
+                return new KeyValuePair<string, object?>("{OriginalFormat}", _OriginalMessage);
+            }
+
+            return new KeyValuePair<string, object?>($"{index}", _Values?[index]);
+        }
+    }
+
+    public int Count
+    {
+        get
+        {
+            return _Values == null ? 1 : _Values.Length + 1;
+        }
+    }
+
+    public IEnumerator<KeyValuePair<string, object?>> GetEnumerator()
+    {
+        for (int i = 0; i < Count; ++i)
+        {
+            yield return this[i];
+        }
+    }
+
+    public override string ToString()
+    {
+        return string.Format(Thread.CurrentThread.CurrentCulture, _OriginalMessage, _Values);
+    }
+
+    IEnumerator IEnumerable.GetEnumerator()
+    {
+        return GetEnumerator();
+    }
+}
diff --git a/src/PSRule.Types/Runtime/ILogger.cs b/src/PSRule.Types/Runtime/ILogger.cs
new file mode 100644
index 0000000000..f8dbc8f934
--- /dev/null
+++ b/src/PSRule.Types/Runtime/ILogger.cs
@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace PSRule.Runtime;
+
+/// <summary>
+/// Log diagnostic messages at runtime.
+/// </summary>
+public interface ILogger
+{
+    /// <summary>
+    /// Determine if the specified type of diagnostic message should be logged.
+    /// </summary>
+    /// <param name="logLevel">The type of the diagnostic message.</param>
+    /// <returns>Returns <c>true</c> if the <see cref="LogLevel"/> should be logged.</returns>
+    public bool IsEnabled(LogLevel logLevel);
+
+    /// <summary>
+    /// Log a diagnostic message.
+    /// </summary>
+    /// <typeparam name="TState">Additional information that describes the diagnostic state to log.</typeparam>
+    /// <param name="logLevel">The type of the diagnostic message.</param>
+    /// <param name="eventId">An event identifier for the diagnostic message.</param>
+    /// <param name="state">Additional information that describes the diagnostic state to log.</param>
+    /// <param name="exception">An optional exception which the diagnostic message is related to.</param>
+    /// <param name="formatter">A function to format the diagnostic message for the outpuyt stream.</param>
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter);
+}
diff --git a/src/PSRule.Types/Runtime/LogLevel.cs b/src/PSRule.Types/Runtime/LogLevel.cs
new file mode 100644
index 0000000000..606d928018
--- /dev/null
+++ b/src/PSRule.Types/Runtime/LogLevel.cs
@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace PSRule.Runtime;
+
+/// <summary>
+/// A set of log levels which indicate different types of diagnostic messages.
+/// </summary>
+public enum LogLevel
+{
+    /// <summary>
+    /// 
+    /// </summary>
+    Trace = 0,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    Debug = 1,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    Information = 2,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    Warning = 3,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    Error = 4,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    Critical = 5,
+
+    /// <summary>
+    /// 
+    /// </summary>
+    None = 6
+}
diff --git a/src/PSRule.Types/Runtime/LoggerExtensions.cs b/src/PSRule.Types/Runtime/LoggerExtensions.cs
new file mode 100644
index 0000000000..d35ad00e02
--- /dev/null
+++ b/src/PSRule.Types/Runtime/LoggerExtensions.cs
@@ -0,0 +1,62 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace PSRule.Runtime;
+
+/// <summary>
+/// Extension for <see cref="ILogger"/> to log diagnostic messages.
+/// </summary>
+public static class LoggerExtensions
+{
+    private static readonly Func<FormattedLogValues, Exception?, string> _messageFormatter = MessageFormatter;
+
+    /// <summary>
+    /// Log a warning message.
+    /// </summary>
+    /// <param name="logger">A valid <see cref="ILogger"/> instance.</param>
+    /// <param name="eventId">An event identifier for the warning.</param>
+    /// <param name="message">The format message text.</param>
+    /// <param name="args">Additional arguments to use within the format message.</param>
+    public static void LogWarning(this ILogger logger, EventId eventId, string? message, params object?[] args)
+    {
+        logger.Log(LogLevel.Warning, eventId, default, message, args);
+    }
+
+    /// <summary>
+    /// Log an error message.
+    /// </summary>
+    /// <param name="logger">A valid <see cref="ILogger"/> instance.</param>
+    /// <param name="eventId">An event identifier for the error.</param>
+    /// <param name="exception">An optional exception which the error message is related to.</param>
+    /// <param name="message">The format message text.</param>
+    /// <param name="args">Additional arguments to use within the format message.</param>
+    public static void LogError(this ILogger logger, EventId eventId, Exception? exception, string? message, params object?[] args)
+    {
+        logger.Log(LogLevel.Error, eventId, exception, message, args);
+    }
+
+    /// <summary>
+    /// Log a diagnostic message.
+    /// </summary>
+    /// <param name="logger">A valid <see cref="ILogger"/> instance.</param>
+    /// <param name="logLevel">The type of diagnostic message.</param>
+    /// <param name="eventId">An event identifier for the diagnostic message.</param>
+    /// <param name="exception">An optional exception which the diagnostic message is related to.</param>
+    /// <param name="message">The format message text.</param>
+    /// <param name="args">Additional arguments to use within the format message.</param>
+    public static void Log(this ILogger logger, LogLevel logLevel, EventId eventId, Exception? exception, string? message, params object?[] args)
+    {
+        if (logger == null || !logger.IsEnabled(logLevel))
+            return;
+
+        logger.Log(logLevel, eventId, new FormattedLogValues(message, args), exception, _messageFormatter);
+    }
+
+    /// <summary>
+    /// Format log messages with values.
+    /// </summary>
+    private static string MessageFormatter(FormattedLogValues state, Exception? error)
+    {
+        return state.ToString();
+    }
+}
diff --git a/src/PSRule/Common/LoggerExtensions.cs b/src/PSRule/Common/LoggerExtensions.cs
index fbc7c0c138..35f7390ad0 100644
--- a/src/PSRule/Common/LoggerExtensions.cs
+++ b/src/PSRule/Common/LoggerExtensions.cs
@@ -8,26 +8,51 @@
 
 namespace PSRule;
 
+/// <summary>
+/// Extension for <see cref="ILogger"/> to log common messages.
+/// </summary>
 internal static class LoggerExtensions
 {
+    private static readonly EventId PSR0004 = new(4, "PSR0004");
+    private static readonly EventId PSR0005 = new(5, "PSR0005");
+
+    /// <summary>
+    /// PSR0005: The {0} '{1}' is obsolete.
+    /// </summary>
     internal static void WarnResourceObsolete(this ILogger logger, ResourceKind kind, string id)
     {
-        if (logger == null || !logger.ShouldLog(LogLevel.Warning))
+        if (logger == null || !logger.IsEnabled(LogLevel.Warning))
             return;
 
-        logger.Warning(PSRuleResources.ResourceObsolete, Enum.GetName(typeof(ResourceKind), kind), id);
+        logger.LogWarning
+        (
+            PSR0005,
+            PSRuleResources.PSR0005,
+            Enum.GetName(typeof(ResourceKind), kind),
+            id
+        );
     }
 
+    /// <summary>
+    /// PSR0004: The specified {0} resource '{1}' is not known.
+    /// </summary>
     internal static void ErrorResourceUnresolved(this ILogger logger, ResourceKind kind, string id)
     {
-        if (logger == null || !logger.ShouldLog(LogLevel.Error))
+        if (logger == null || !logger.IsEnabled(LogLevel.Error))
             return;
 
-        logger.Error(new PipelineBuilderException(string.Format(
-            Thread.CurrentThread.CurrentCulture,
+        logger.LogError
+        (
+            PSR0004,
+            new PipelineBuilderException(string.Format(
+                Thread.CurrentThread.CurrentCulture,
+                PSRuleResources.PSR0004,
+                Enum.GetName(typeof(ResourceKind),
+                kind), id
+            )),
             PSRuleResources.PSR0004,
-            Enum.GetName(typeof(ResourceKind),
-            kind), id
-        )), "PSR0004");
+            Enum.GetName(typeof(ResourceKind), kind),
+            id
+        );
     }
 }
diff --git a/src/PSRule/Resources/PSRuleResources.Designer.cs b/src/PSRule/Resources/PSRuleResources.Designer.cs
index b5027f9a6c..46329418c3 100644
--- a/src/PSRule/Resources/PSRuleResources.Designer.cs
+++ b/src/PSRule/Resources/PSRuleResources.Designer.cs
@@ -591,6 +591,15 @@ internal static string PSR0004 {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to PSR0005: The {0} &apos;{1}&apos; is obsolete..
+        /// </summary>
+        internal static string PSR0005 {
+            get {
+                return ResourceManager.GetString("PSR0005", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Failed to deserialize the file &apos;{0}&apos;: {1}.
         /// </summary>
@@ -636,15 +645,6 @@ internal static string RequiredVersionMismatch {
             }
         }
         
-        /// <summary>
-        ///   Looks up a localized string similar to The {0} &apos;{1}&apos; is obsolete. Consider switching to an alternative {0}..
-        /// </summary>
-        internal static string ResourceObsolete {
-            get {
-                return ResourceManager.GetString("ResourceObsolete", resourceCulture);
-            }
-        }
-        
         /// <summary>
         ///   Looks up a localized string similar to {0} rule/s were suppressed for &apos;{1}&apos;..
         /// </summary>
diff --git a/src/PSRule/Resources/PSRuleResources.resx b/src/PSRule/Resources/PSRuleResources.resx
index 1aa7b83796..6bef017a69 100644
--- a/src/PSRule/Resources/PSRuleResources.resx
+++ b/src/PSRule/Resources/PSRuleResources.resx
@@ -117,8 +117,8 @@
   <resheader name="writer">
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
-  <data name="ResourceObsolete" xml:space="preserve">
-    <value>The {0} '{1}' is obsolete. Consider switching to an alternative {0}.</value>
+  <data name="PSR0005" xml:space="preserve">
+    <value>PSR0005: The {0} '{1}' is obsolete.</value>
     <comment>Occurs when a resource is used that has been flagged as obsolete.</comment>
   </data>
   <data name="ArgumentFormatInvalid" xml:space="preserve">
diff --git a/src/PSRule/Runtime/ILogger.cs b/src/PSRule/Runtime/ILogger.cs
deleted file mode 100644
index e798490126..0000000000
--- a/src/PSRule/Runtime/ILogger.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-namespace PSRule.Runtime;
-
-/// <summary>
-/// A generic interface for diagnostic logging within PSRule.
-/// </summary>
-internal interface ILogger
-{
-    /// <summary>
-    /// Determines if a specific log level should be written.
-    /// </summary>
-    /// <param name="level">The level to query.</param>
-    /// <returns>Returns <c>true</c> when the log level should be written or <c>false</c> otherwise.</returns>
-    bool ShouldLog(LogLevel level);
-
-    /// <summary>
-    /// Write a warning.
-    /// </summary>
-    /// <param name="message">The warning message write.</param>
-    /// <param name="args">Any arguments to format the string with.</param>
-    void Warning(string message, params object[] args);
-
-    /// <summary>
-    /// Write an error from an exception.
-    /// </summary>
-    /// <param name="exception">The exception to write.</param>
-    /// <param name="errorId">A string identifier for the error.</param>
-    void Error(Exception exception, string errorId = null);
-}
diff --git a/src/PSRule/Runtime/LogLevel.cs b/src/PSRule/Runtime/LogLevel.cs
deleted file mode 100644
index 2dcb10ba5b..0000000000
--- a/src/PSRule/Runtime/LogLevel.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-namespace PSRule.Runtime;
-
-/// <summary>
-/// A set of log levels which indicate different types of diagnostic messages.
-/// </summary>
-[Flags]
-internal enum LogLevel
-{
-    None = 0,
-
-    Error = 1,
-
-    Warning = 2,
-
-    Info = 4,
-
-    Verbose = 8,
-
-    Debug = 16,
-}
diff --git a/src/PSRule/Runtime/RunspaceContext.cs b/src/PSRule/Runtime/RunspaceContext.cs
index bcb84cf033..44e3203e76 100644
--- a/src/PSRule/Runtime/RunspaceContext.cs
+++ b/src/PSRule/Runtime/RunspaceContext.cs
@@ -852,34 +852,53 @@ internal bool TryGetConfigurationValue(string name, out object value)
     #region ILogger
 
     /// <inheritdoc/>
-    public bool ShouldLog(LogLevel level)
+    bool ILogger.IsEnabled(LogLevel logLevel)
     {
         return Writer != null && (
-            (level == LogLevel.Warning && Writer.ShouldWriteWarning()) ||
-            (level == LogLevel.Error && Writer.ShouldWriteError()) ||
-            (level == LogLevel.Info && Writer.ShouldWriteInformation()) ||
-            (level == LogLevel.Verbose && Writer.ShouldWriteVerbose()) ||
-            (level == LogLevel.Debug && Writer.ShouldWriteDebug())
+            (logLevel == LogLevel.Warning && Writer.ShouldWriteWarning()) ||
+            ((logLevel == LogLevel.Error || logLevel == LogLevel.Critical) && Writer.ShouldWriteError()) ||
+            (logLevel == LogLevel.Information && Writer.ShouldWriteInformation()) ||
+            (logLevel == LogLevel.Debug && Writer.ShouldWriteVerbose()) ||
+            (logLevel == LogLevel.Trace && Writer.ShouldWriteDebug())
         );
     }
 
+#nullable enable
+
     /// <inheritdoc/>
-    public void Warning(string message, params object[] args)
+    void ILogger.Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
     {
-        if (Writer == null || string.IsNullOrEmpty(message))
-            return;
+        if (Writer == null) return;
 
-        Writer.WriteWarning(message, args);
+        if (logLevel == LogLevel.Error || logLevel == LogLevel.Critical)
+        {
+            Writer.WriteError(new ErrorRecord(exception, eventId.Id.ToString(), ErrorCategory.InvalidOperation, null));
+        }
+        else if (logLevel == LogLevel.Warning)
+        {
+            Writer.WriteWarning(formatter(state, exception));
+        }
+        else if (logLevel == LogLevel.Information)
+        {
+            Writer.WriteInformation(new InformationRecord(formatter(state, exception), null));
+        }
+        else if (logLevel == LogLevel.Debug)
+        {
+            Writer.WriteDebug(formatter(state, exception));
+        }
+        else if (logLevel == LogLevel.Trace)
+        {
+            Writer.WriteVerbose(formatter(state, exception));
+        }
     }
 
-    /// <inheritdoc/>
-    public void Error(Exception exception, string errorId = null)
-    {
-        if (Writer == null || exception == null)
-            return;
+    ///// <inheritdoc/>
+    //IDisposable? ILogger.BeginScope<TState>(TState state) //where TState : notnull
+    //{
+    //    throw new NotImplementedException();
+    //}
 
-        Writer.WriteError(new ErrorRecord(exception, errorId, ErrorCategory.InvalidOperation, null));
-    }
+#nullable restore
 
     #endregion ILogger
 
diff --git a/tests/PSRule.Tests/PSRule.Baseline.Tests.ps1 b/tests/PSRule.Tests/PSRule.Baseline.Tests.ps1
index fa30160645..83a4d7d342 100644
--- a/tests/PSRule.Tests/PSRule.Baseline.Tests.ps1
+++ b/tests/PSRule.Tests/PSRule.Baseline.Tests.ps1
@@ -833,7 +833,7 @@ Describe 'Baseline' -Tag 'Baseline' {
             $Null = @($testObject | Invoke-PSRule -Path $ruleFilePath,$baselineFilePath -Baseline 'TestBaseline5' -WarningVariable outWarn -WarningAction SilentlyContinue);
             $warnings = @($outWarn);
             $warnings.Length | Should -Be 1;
-            $warnings[0] | Should -BeExactly "The Baseline '.\TestBaseline5' is obsolete. Consider switching to an alternative Baseline.";
+            $warnings[0] | Should -BeExactly "PSR0005: The Baseline '.\TestBaseline5' is obsolete.";
         }
 
         It 'With scoped configuration' {