GlobalLogger.cs

Go to the documentation of this file.

// Copyright (c) 2014 Silicon Studio Corp. (http://siliconstudio.co.jp)
// This file is distributed under GPL v3. See LICENSE.md for details.
using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

namespace SiliconStudio.Core.Diagnostics
{
    /// <summary>
    /// A logger that redirect messages to a global handler and handle instantiated MapModuleNameToLogger.
    /// </summary>
    public sealed class GlobalLogger : Logger
    {
        #region Constants and Fields

        /// <summary>
        /// By default, the minimum level for a GlobalLogger is info.
        /// </summary>
        public const LogMessageType MinimumLevel = LogMessageType.Info;

        /// <summary>
        /// Map for all instantiated loggers. Map a module name to a logger.
        /// </summary>
        private static readonly Dictionary<string, Logger> MapModuleNameToLogger = new Dictionary<string, Logger>();

        #endregion

        private GlobalLogger(string module)
        {
            Module = module;
        }

        public delegate void MessageFilterDelegate(ref ILogMessage logMessage);

        /// <summary>
        /// Occurs before a message is logged.
        /// </summary>
        public static event MessageFilterDelegate GlobalMessageFilter;

        /// <summary>
        /// Occurs when a message is logged.
        /// </summary>
        public static event Action<ILogMessage> GlobalMessageLogged;

        /// <summary>
        /// Gets all registered loggers.
        /// </summary>
        /// <value>The registered loggers.</value>
        public static Logger[] RegisteredLoggers
        {
            get
            {
                lock (MapModuleNameToLogger)
                {
                    var loggers = new Logger[MapModuleNameToLogger.Count];
                    MapModuleNameToLogger.Values.CopyTo(loggers, 0);
                    return loggers;
                }
            }
        }

        /// <summary>
        /// Activates the log for all loggers using the specified action..
        /// </summary>
        /// <param name="activator">The activator.</param>
        /// <exception cref="ArgumentNullException">If activator is null</exception>
        public static void ActivateLog(Action<Logger> activator)
        {
            if (activator == null)
                throw new ArgumentNullException("activator");

            foreach (var logger in MapModuleNameToLogger.Values)
                activator(logger);
        }

        /// <summary>
        /// Activates the log for loggers that match a regex pattern on the module name.
        /// </summary>
        /// <param name="regexPatternModule">The regex pattern to match a module name.</param>
        /// <param name="minimumLevel">The minimum level.</param>
        /// <param name="maximumLevel">The maximum level.</param>
        /// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param>
        /// <exception cref="ArgumentNullException">If regexPatternModule is null</exception>
        public static void ActivateLog(string regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true)
        {
            if (regexPatternModule == null)
                throw new ArgumentNullException("regexPatternModule");

            var regex = new Regex(regexPatternModule);
            ActivateLog(regex, minimumLevel, maximumLevel);
        }

        /// <summary>
        /// Activates the log for loggers that match a regex pattern on the module name.
        /// </summary>
        /// <param name="regexPatternModule">The regex pattern to match a module name.</param>
        /// <param name="minimumLevel">The minimum level.</param>
        /// <param name="maximumLevel">The maximum level.</param>
        /// <param name="enabledFlag">if set to <c>true</c> enaable the log, else disable.</param>
        /// <exception cref="ArgumentNullException">If regexPatternModule is null</exception>
        public static void ActivateLog(Regex regexPatternModule, LogMessageType minimumLevel, LogMessageType maximumLevel = LogMessageType.Fatal, bool enabledFlag = true)
        {
            if (regexPatternModule == null)
                throw new ArgumentNullException("regexPatternModule");

            ActivateLog(
                logger =>
                    {
                        if (regexPatternModule.Match(logger.Module).Success)
                        {
                            logger.ActivateLog(minimumLevel, maximumLevel, enabledFlag);
                        }
                    });
        }

        /// <summary>
        /// Gets the <see cref="GlobalLogger"/> associated to the specified module.
        /// </summary>
        /// <param name="module">The module name.</param>
        /// <exception cref="ArgumentNullException">If module name is null</exception>
        /// <returns>An instance of a <see cref="Logger"/></returns>
        public static Logger GetLogger(string module)
        {
            if (module == null)
                throw new ArgumentNullException("module");

            Logger logger;
            lock (MapModuleNameToLogger)
            {
                if (!MapModuleNameToLogger.TryGetValue(module, out logger))
                {
                    logger = new GlobalLogger(module);
                    logger.ActivateLog(MinimumLevel);
                    MapModuleNameToLogger.Add(module, logger);
                }
            }
            return logger;
        }

        protected override void LogRaw(ILogMessage logMessage)
        {
            var filterHandler = GlobalMessageFilter;
            if (filterHandler != null)
            {
                filterHandler(ref logMessage);
                if (logMessage == null)
                    return;
            }

            var handler = GlobalMessageLogged;
            if (handler != null) handler(logMessage);
        }
    }
}