IIdentityLogger

IIdentityLogger.cs

using System;
using System.Diagnostics.Tracing;
using Windows.Security.Authentication.Web.Core;

namespace ConsoleApp2
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // App developer configures logger
            IIdentityLogger logger = new ConsoleLoggerImpl(EventLevel.LogAlways, isPiiEnabled: true);
            
            
            // Now MSAL outputs some log messages
            MsalInternalLogging msalInternalLogging = new MsalInternalLogging(logger);

            msalInternalLogging.Log(EventLevel.Informational, "Info message no pii", "Info message with pii");
            msalInternalLogging.Log(EventLevel.Informational, "Info message2 no pii");

            msalInternalLogging.Log(EventLevel.Verbose, "Verobse message no pii", "Verbose with pii");
            msalInternalLogging.Log(EventLevel.Verbose, "Verobse message2 no pii");

            msalInternalLogging.Log(EventLevel.LogAlways, "LogAlways message no pii", "LogAlways message with pii");
            msalInternalLogging.Log(EventLevel.LogAlways, "LogAlways message2 no pii");

            msalInternalLogging.Log(EventLevel.Error, "Error message no pii", "Error message with pii");
            msalInternalLogging.Log(EventLevel.Error, "Error message2 no pii");

            // important scenario: SAL / MSAL etc. need to sometimes log messages that are "expensive" to compute, for example in verbose mode we print the metadata of the first 10 tokens in the cache 
            if (msalInternalLogging.IsLogLevelEnabled(EventLevel.Verbose))
            {
                msalInternalLogging.Log(EventLevel.Verbose, GetExpensiveLogMessage());
            }

            Console.Read();
        }

        private static string GetExpensiveLogMessage()
        {
            Console.WriteLine("EXPENSIVE LOG MESSAGE COMPUTED. Is this expected?");

            return "This is an expensive verbose message";
        }
    }

    public class MsalInternalLogging
    {
        private readonly IIdentityLogger _logger;

        public MsalInternalLogging(IIdentityLogger logger)
        {
            _logger = logger;
        }

        public bool IsLogLevelEnabled(EventLevel level)
        {
            return (level <= _logger.MinLogLevel);
        }

        public void Log(EventLevel level, string messageNoPii)
        {
            if (IsLogLevelEnabled(level))
            {
                _logger.Log(new LogEntry()
                {
                    EventLevel = level,
                    Message = messageNoPii,
                    HasPii = false
                });
            }
        }

        public void Log(EventLevel level, string messageNoPii, string messageWithPii)
        {
            if (IsLogLevelEnabled(level))
            {
                if (_logger.IsPiiEnabled)
                {
                    _logger.Log(new LogEntry()
                    {
                        EventLevel = level,
                        Message = messageWithPii,
                        HasPii = true
                    });
                }
                else
                {
                    _logger.Log(new LogEntry()
                    {
                        EventLevel = level,
                        Message = messageNoPii,
                        HasPii = false
                    });
                }
            }
        }
    }

    public class ConsoleLoggerImpl : IIdentityLogger
    {
        public ConsoleLoggerImpl(EventLevel level, bool isPiiEnabled)
        {
            MinLogLevel = level;
            IsPiiEnabled = isPiiEnabled;
        }


        public bool IsPiiEnabled { get; }

        public EventLevel MinLogLevel
        {
            get;
        }

        public void Log(LogEntry entry)
        {
            Console.WriteLine($"{entry.EventLevel} {entry.HasPii} {entry.Message} ");
        }
    }

    public interface IIdentityLogger // part of new package
    {
        /// <summary>
        /// 
        /// </summary>
        bool IsPiiEnabled { get; }

        EventLevel MinLogLevel { get; }

        /// <summary>
        /// Writes a log entry.
        /// </summary>
        /// <param name="entry">Defines a structured message to be logged at the provided <see cref="LogEntry.EventLevel"/>.</param>
        void Log(LogEntry entry);
    }

    /// </summary>
    public class LogEntry // part of new package
    {
        public bool HasPii { get; set; }

        /// <summary>
        /// Defines the <see cref="EventLevel"/>.
        /// </summary>
        public EventLevel EventLevel { get; set; }

        /// <summary>
        /// Message to be logged.
        /// </summary>
        public string Message { get; set; }

        // TODO: is this needed? MSAL / SAL / Wilson will automatically add correlation id to the message?

        ///// <summary>
        ///// A unique identifier for a request that can help with diagnostics across components.
        ///// </summary>
        //public string CorrelationId { get; set; }
    }
}