using System.Collections.Generic;
using System.Diagnostics;

using UnityEngine;

using Ubisoft;

// Use this class if your project already uses Debug.Log() intensely, otherwise using Ubisoft.Hotel.Logger class is the recommended approach.
//
// This class is responsible for overriding UnityEngine.Debug behaviour in order to extend functionaly and in order to be able to strip out both its methods
// implementation and the calls to these methods depending on the symbols defined.
//
// Case 1: The whole call will be stripped out in the final build so you don't have to worry about the allocation that otherwise concatening those strings would cause
// Debug.Log("Message: " + foo);
//
// Case 2: You need to strip out msg yourself
// string msg = "Message " + foo;
// Debug.Log(msg);
//
// Case 3: Calling a Log() method defined by the user won't strip out the call to that method unless the user does it herself by using the same approach as the one described above
// UserClass.Log("Message " + foo);

public class Debug
{
    private const string DEBUG = "DEBUG";

    internal const string HT_LOGGER_ASSERT_ON = HtLogger.HT_LOGGER_ASSERT_ON;
    internal const string HT_LOGGER_LOG_ON = HtLogger.HT_LOGGER_TRACE_ON;
    internal const string HT_LOGGER_TRACE_ON = HtLogger.HT_LOGGER_TRACE_ON;
    internal const string HT_LOGGER_DEBUG_ON = HtLogger.HT_LOGGER_DEBUG_ON;
    internal const string HT_LOGGER_INFORMATION_ON = HtLogger.HT_LOGGER_INFORMATION_ON;
    internal const string HT_LOGGER_WARNING_ON = HtLogger.HT_LOGGER_WARNING_ON;
    internal const string HT_LOGGER_ERROR_ON = HtLogger.HT_LOGGER_ERROR_ON;
    internal const string HT_LOGGER_CRITICAL_ON = HtLogger.HT_LOGGER_CRITICAL_ON;
    internal const string HT_LOGGER_EXCEPTION_ON = HtLogger.HT_LOGGER_EXCEPTION_ON;

    public static readonly List<string> HT_LOGGER_SYMBOLS = new List<string>()
    {
        HT_LOGGER_ASSERT_ON,
        HT_LOGGER_LOG_ON,
        HT_LOGGER_TRACE_ON,
        HT_LOGGER_DEBUG_ON,
        HT_LOGGER_INFORMATION_ON,
        HT_LOGGER_WARNING_ON,
        HT_LOGGER_ERROR_ON,
        HT_LOGGER_CRITICAL_ON
    };

    private static HtLogger s_logger;

    public static HtLogger Logger
    {
        get
        {
            if (s_logger == null)
            {
                s_logger = HtLogger.Instance;
            }

            return s_logger;
        }
    }

    /// <summary>
    /// Create a channel. Channels help you keep your logs organized. You are not allowed to instantiate directly a channel, instead, you need to use this method,
    /// so Logger can track all channels created around.
    /// </summary>
    /// <param name="name">Name of the channel</param>
    /// <param name="color">Color for the messages logged to log levels ((Trace, Debug and Information)) that don't have their own color</param>
    /// <returns></returns>
    public static HtLogger.Channel CreateChannel(string name, string color = null)
    {
        return Logger.CreateChannel(name, color);
    }

    public static List<HtLogger.Channel> Channels
    {
        get
        {
            return Logger.Channels;
        }
    }

    /// <summary>
    /// Enable all channels. By default all channels are enabled. Use this method after having used <c>DisableAllChannels()</c>
    /// when you want to go back to the default status.
    /// </summary>
    public static void EnableAllChannels()
    {
        Logger.EnableAllChannels();
    }

    /// <summary>
    /// Disable all channels.
    /// </summary>
    public static void DisableAllChannels()
    {
        Logger.DisableAllChannels();
    }

    /// <summary>
    /// Enable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
    /// </summary>
    /// <param name="channelNames">Set of channel names to disable.</param>
    public static void EnableAllChannelsExcept(HashSet<string> channelNames)
    {
        Logger.EnableAllChannelsExcept(channelNames);
    }

    /// <summary>
    /// Disable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
    /// </summary>
    /// <param name="channelNames">Set of channel names to enable.</param>
    public static void DisableAllChannelsExcept(HashSet<string> channelNames)
    {
        Logger.DisableAllChannelsExcept(channelNames);
    }

    /// <summary>
    /// Enable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
    /// </summary>
    /// <param name="channels">Set of channels to disable.</param>
    public static void EnableAllChannelsExcept(HashSet<HtLogger.Channel> channels)
    {
        Logger.EnableAllChannelsExcept(channels);
    }

    /// <summary>
    /// Disable all channels except the ones which names are passed in. Disabling channels may be useful when you want to reduce noise while debugging a given feature.
    /// </summary>
    /// <param name="channels">Set of channels to enable.</param>
    public static void DisableAllChannelsExcept(HashSet<HtLogger.Channel> channels)
    {
        Logger.DisableAllChannelsExcept(channels);
    }

    //
    // Assert
    //
    // <summary>
    /// Assert a condition and log a generic error message to all Logger streams on failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void Assert(bool condition)
    {
        Logger.Assert(condition);
    }

    //
    // Log
    //

    /// <summary>
    /// Log a Trace message to all Logger streams.
    ///
    /// This method exists only to keep compatibility but <c>LogTrace()</c> is preferred since it conforms to Microsoft Logging specifications.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <summary>
    [Conditional(HT_LOGGER_LOG_ON)]
    public static void Log(object message)
    {
        Logger.LogTrace(message);
    }

    /// <summary>
    /// Log a Trace message to all Logger streams.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void LogTrace(object message)
    {
        Logger.LogTrace(message);
    }

    /// <summary>
    /// Log a Debug message to all Logger streams.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void LogDebug(object message)
    {
        Logger.LogDebug(message);
    }

    /// <summary>
    /// Log an Information message to all Logger streams.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void LogInformation(object message)
    {
        Logger.LogInformation(message);
    }

    /// <summary>
    /// Log a Warning message to all Logger streams.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void LogWarning(object message)
    {
        Logger.LogWarning(message);
    }

    /// <summary>
    /// Log an Error message to all Logger streams.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void LogError(object message)
    {
        Logger.LogError(message);
    }

    /// <summary>
    /// Log a Critical message to all Logger streams.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void LogCritical(object message)
    {
        Logger.LogCritical(message);
    }

    /// <summary>
    /// Assert a condition and log an error message to all Logger streams on failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void Assert(bool condition, object message)
    {
        Logger.Assert(condition, message);
    }

    /// <summary>
    /// Log an assertion message to all Logger streams.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void LogAssertion(object message)
    {
        Logger.LogAssertion(message);
    }

    /// <summary>
    /// Log an exception to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="exception">Exception to log.</param>
    [Conditional(HT_LOGGER_EXCEPTION_ON)]
    public static void LogException(System.Exception exception)
    {
        Logger.LogException(exception);
    }

    //
    // Log with context
    //

    /// <summary>
    /// Log a Trace message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// This method exists only to keep compatibility but <c>LogTrace()</c> is preferred since it conforms to Microsoft Logging specifications.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_LOG_ON)]
    public static void Log(object message, Object context)
    {
        Logger.LogTrace(message, context);
    }

    /// <summary>
    /// Log a Trace message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void LogTrace(object message, Object context)
    {
        Logger.LogTrace(message, context);
    }

    /// <summary>
    /// Log a Debug message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void LogDebug(object message, Object context)
    {
        Logger.LogDebug(message, context);
    }

    /// <summary>
    /// Log an Information message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void LogInformation(object message, Object context)
    {
        Logger.LogInformation(message, context);
    }

    /// <summary>
    /// Log a Warning message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void LogWarning(object message, Object context)
    {
        Logger.LogWarning(message, context);
    }

    /// <summary>
    /// Log an Error message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void LogError(object message, Object context)
    {
        Logger.LogError(message, context);
    }

    /// <summary>
    /// Log a Critical message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void LogCritical(object message, Object context)
    {
        Logger.LogCritical(message, context);
    }

    /// <summary>
    /// Assert a condition, log an error message to all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void Assert(bool condition, object message, Object context)
    {
        Logger.Assert(condition, message, context);
    }

    /// <summary>
    /// Log an assertion message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void LogAssertion(object message, Object context)
    {
        Logger.LogAssertion(message, context);
    }

    /// <summary>
    /// Log an exception to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="exception">Exception to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_EXCEPTION_ON)]
    public static void LogException(System.Exception exception, Object context)
    {
        Logger.LogException(exception, context);
    }

    //
    // Log with format
    //

    /// <summary>
    /// Log a formated Trace message to all Logger streams.
    ///
    /// This method exists only to keep compatibility but <c>LogTraceFormat()</c> is preferred since it conforms to Microsoft Logging specifications.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_LOG_ON)]
    public static void LogFormat(string format, params object[] args)
    {
        Logger.LogTraceFormat(format, args);
    }

    /// <summary>
    /// Log a formated Trace message to all Logger streams.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void LogTraceFormat(string format, params object[] args)
    {
        Logger.LogTraceFormat(format, args);
    }

    /// <summary>
    /// Log a formatted Debug message to all Logger streams.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void LogDebugFormat(string format, params object[] args)
    {
        Logger.LogDebugFormat(format, args);
    }

    /// <summary>
    /// Log a formatted Information message to all Logger streams.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void LogInformationFormat(string format, params object[] args)
    {
        Logger.LogInformationFormat(format, args);
    }

    /// <summary>
    /// Log a formatted Warning message to all Logger streams.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void LogWarningFormat(string format, params object[] args)
    {
        Logger.LogWarningFormat(format, args);
    }

    /// <summary>
    /// Log a formatted Error message to all Logger streams.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void LogErrorFormat(string format, params object[] args)
    {
        Logger.LogErrorFormat(format, args);
    }

    /// <summary>
    /// Log a formatted Critical message to all Logger streams.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void LogCriticalFormat(string format, params object[] args)
    {
        Logger.LogCriticalFormat(format, args);
    }

    /// <summary>
    /// Assert a condition and log a formatted error message to all Logger streams on failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void AssertFormat(bool condition, string format, params object[] args)
    {
        Logger.AssertFormat(condition, format, args);
    }

    /// <summary>
    /// Log a formatted assertion message to all Logger streams.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void LogAssertionFormat(string format, params object[] args)
    {
        Logger.LogAssertionFormat(format, args);
    }

    //
    // Log with context and format
    //

    /// <summary>
    /// Log a formated Trace message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// This method exists only to keep compatibility but <c>LogTraceFormat()</c> is preferred since it conforms to Microsoft Logging specifications.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_LOG_ON)]
    public static void LogFormat(Object context, string format, params object[] args)
    {
        Logger.LogTraceFormat(context, format, args);
    }

    /// <summary>
    /// Log a formated Trace message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void LogTraceFormat(Object context, string format, params object[] args)
    {
        Logger.LogTraceFormat(context, format, args);
    }

    /// <summary>
    /// Log a formatted Debug message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void LogDebugFormat(Object context, string format, params object[] args)
    {
        Logger.LogDebugFormat(context, format, args);
    }

    /// <summary>
    /// Log a formatted Information message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void LogInformationFormat(Object context, string format, params object[] args)
    {
        Logger.LogInformationFormat(context, format, args);
    }

    /// <summary>
    /// Log a formatted Warning message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void LogWarningFormat(Object context, string format, params object[] args)
    {
        Logger.LogWarningFormat(context, format, args);
    }

    /// <summary>
    /// Log a formatted Error message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void LogErrorFormat(Object context, string format, params object[] args)
    {
        Logger.LogErrorFormat(context, format, args);
    }

    /// <summary>
    /// Log a formatted Critical message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void LogCriticalFormat(Object context, string format, params object[] args)
    {
        Logger.LogCriticalFormat(context, format, args);
    }

    /// <summary>
    /// Assert a condition, log a formatted error message to all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void AssertFormat(bool condition, Object context, string format, params object[] args)
    {
        Logger.AssertFormat(condition, context, format, args);
    }

    /// <summary>
    /// Log a formatted assertion message to all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void LogAssertionFormat(Object context, string format, params object[] args)
    {
        Logger.LogAssertionFormat(context, format, args);
    }

    //
    // Log with channel
    //

    /// <summary>
    /// Log a Trace message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Trace()</c> instead if you need more control over the channel.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void ChannelLogTrace(string channel, object message)
    {
        Logger.ChannelLogTrace(channel, message);
    }

    /// <summary>
    /// Log a Debug message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Debug()</c> instead if you need more control over the channel.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void ChannelLogDebug(string channel, object message)
    {
        Logger.ChannelLogDebug(channel, message);
    }

    /// <summary>
    /// Log an Information message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Information()</c> instead if you need more control over the channel.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void ChannelLogInformation(string channel, object message)
    {
        Logger.ChannelLogInformation(channel, message);
    }

    /// <summary>
    /// Log a Warning message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Warning()</c> instead if you need more control over the channel.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void ChannelLogWarning(string channel, object message)
    {
        Logger.ChannelLogWarning(channel, message);
    }

    /// <summary>
    /// Log an Error message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Error()</c> instead if you need more control over the channel.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void ChannelLogError(string channel, object message)
    {
        Logger.ChannelLogError(channel, message);
    }

    /// <summary>
    /// Log a Critical message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Critical()</c> instead if you need more control over the channel.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void ChannelLogCritical(string channel, object message)
    {
        Logger.ChannelLogCritical(channel, message);
    }

    /// <summary>
    /// Assert a condition and log an error message to a channel for all Logger streams on failure.
    ///
    /// Use <c>ChannelLogger.Assert()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelAssert(string channel, bool condition, object message)
    {
        Logger.ChannelAssert(channel, condition, message);
    }

    /// <summary>
    /// Log an assertion message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Assertion()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelLogAssertion(string channel, object message)
    {
        Logger.ChannelLogAssertion(channel, message, null);
    }

    //
    // Log with channel and context
    //

    /// <summary>
    /// Log a Trace message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Trace()</c> instead if you need more control over the channel.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void ChannelLogTrace(string channel, object message, Object context)
    {
        Logger.ChannelLogTrace(channel, message, context);
    }

    /// <summary>
    /// Log a Debug message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Debug()</c> instead if you need more control over the channel.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void ChannelLogDebug(string channel, object message, Object context)
    {
        Logger.ChannelLogDebug(channel, message, context);
    }

    /// <summary>
    /// Log an Information message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Information()</c> instead if you need more control over the channel.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void ChannelLogInformation(string channel, object message, Object context)
    {
        Logger.ChannelLogInformation(channel, message, context);
    }

    /// <summary>
    /// Log a Warning message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Warning<()/c> instead if you need more control over the channel.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void ChannelLogWarning(string channel, object message, Object context)
    {
        Logger.ChannelLogWarning(channel, message, context);
    }

    /// <summary>
    /// Log an Error message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Error()</c> instead if you need more control over the channel.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void ChannelLogError(string channel, object message, Object context)
    {
        Logger.ChannelLogError(channel, message, context);
    }

    /// <summary>
    /// Log a Critical message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Critical()</c> instead if you need more control over the channel.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void ChannelLogCritical(string channel, object message, Object context)
    {
        Logger.ChannelLogCritical(channel, message, context);
    }
    /// <summary>
    /// Assert a condition, log an error message to a channel for all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Assert()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelAssert(string channel, bool condition, object message, Object context)
    {
        Logger.ChannelAssert(channel, condition, message, context);
    }

    /// <summary>
    /// Log an assertion message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Assertion()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="message">Message to log.</param>
    /// <param name="context">Object to which the message applies.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelLogAssertion(string channel, object message, Object context)
    {
        Logger.ChannelLogAssertion(channel, message, context);
    }

    //
    // Log with channel and format
    //

    /// <summary>
    /// Log a formated Trace message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.TraceFormat()</c> instead if you need more control over the channel.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_LOG_ON)]
    public static void ChannelLogFormat(string channel, string format, params object[] args)
    {
        Logger.ChannelLogTraceFormat(channel, format, args);
    }

    /// <summary>
    /// Log a formated Trace message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.TraceFormat()</c> instead if you need more control over the channel.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void ChannelLogTraceFormat(string channel, string format, params object[] args)
    {
        Logger.ChannelLogTraceFormat(channel, format, args);
    }

    /// <summary>
    /// Log a formatted Debug message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.DebugFormat()</c> instead if you need more control over the channel.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void ChannelLogDebugFormat(string channel, string format, params object[] args)
    {
        Logger.ChannelLogDebugFormat(channel, format, args);
    }

    /// <summary>
    /// Log a formatted Information message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.InformationFormat()</c> instead if you need more control over the channel.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void ChannelLogInformationFormat(string channel, string format, params object[] args)
    {
        Logger.ChannelLogInformationFormat(channel, format, args);
    }

    /// <summary>
    /// Log a formatted Warning message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.WarningFormat()</c> instead if you need more control over the channel.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void ChannelLogWarningFormat(string channel, string format, params object[] args)
    {
        Logger.ChannelLogWarningFormat(channel, format, args);
    }

    /// <summary>
    /// Log a formatted Error message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.ErrorFormat()</c> instead if you need more control over the channel.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void ChannelLogErrorFormat(string channel, string format, params object[] args)
    {
        Logger.ChannelLogErrorFormat(channel, format, args);
    }

    /// <summary>
    /// Log a formatted Critical message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.CriticalFormat()</c> instead if you need more control over the channel.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void ChannelLogCriticalFormat(string channel, string format, params object[] args)
    {
        Logger.ChannelLogCriticalFormat(channel, format, args);
    }

    /// <summary>
    /// Assert a condition and log a formatted error message to a channel for all Logger streams on failure.
    ///
    /// Use <c>Channel.AssertFormat()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelAssertFormat(string channel, bool condition, string format, params object[] args)
    {
        Logger.ChannelAssertFormat(channel, condition, format, args);
    }

    /// <summary>
    /// Log a formatted assertion message to a channel for all Logger streams.
    ///
    /// Use <c>ChannelLogger.Assertion()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelLogAssertion(string channel, string format, params object[] args)
    {
        Logger.ChannelLogAssertion(channel, format, args, null);
    }

    //
    //  Log with channel, context and format
    //

    /// <summary>
    /// Log a formated Trace message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.TraceFormat()</c> instead if you need more control over the channel.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_LOG_ON)]
    public static void ChannelLogFormat(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogTraceFormat(channel, context, format, args);
    }

    /// <summary>
    /// Log a formated Trace message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.TraceFormat()</c> instead if you need more control over the channel.
    ///
    /// Trace logs contain the most detailed messages. These messages may contain sensitive application data.
    /// These messages are disabled by default and should never be enabled in a production environment.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Trace</c>. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_TRACE_ON)]
    public static void ChannelLogTraceFormat(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogTraceFormat(channel, context, format, args);
    }

    /// <summary>
    /// Log a formatted Debug message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.DebugFormat()</c> instead if you need more control over the channel.
    ///
    /// Debug logs are used for interactive investigation during development. These logs should primarily contain information useful
    /// for debugging and have no long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Debug</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_DEBUG_ON)]
    public static void ChannelLogDebugFormat(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogDebugFormat(channel, context, format, args);
    }

    /// <summary>
    /// Log a formatted Information message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.InformationFormat()</c> instead if you need more control over the channel.
    ///
    /// Information logs track the general flow of the application (breadcrumbs). These logs should have long-term value.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Information</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_INFORMATION_ON)]
    public static void ChannelLogInformationFormat(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogInformationFormat(channel, context, format, args);
    }

    /// <summary>
    /// Log a formatted Warning message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.WarningFormat()</c> instead if you need more control over the channel.
    ///
    /// Warning logs highlight an abnormal or unexpected event in the application flow, but do not otherwise cause the application execution to stop.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Warning</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_WARNING_ON)]
    public static void ChannelLogWarningFormat(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogWarningFormat(channel, context, format, args);
    }

    /// <summary>
    /// Log a formatted Error message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.ErrorFormat()</c> instead if you need more control over the channel.
    ///
    /// Error logs highlight when the current flow of execution is stopped due to a failure. These should indicate a failure in the current activity, not an application-wide failure.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Error</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ERROR_ON)]
    public static void ChannelLogErrorFormat(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogErrorFormat(channel, context, format, args);
    }

    /// <summary>
    /// Log a formatted Critical message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.CriticalFormat()</c> instead if you need more control over the channel.
    ///
    /// Critical logs describe an unrecoverable application or system crash, or a catastrophic failure that requires immediate attention.
    ///
    /// Note that this method works only if <c>LoggerProperty.MinLogLevel</c> is <c>ELogLevel.Critical</c> or less. Otherwise this method and the calls to
    /// this method will be stripped out avoiding all impact in performance and build size.
    ///
    /// More information on deciding the log level to use here:
    /// https://docs.microsoft.com/en-us/dotnet/api/microsoft.extensions.logging.loglevel?view=dotnet-plat-ext-5.0
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_CRITICAL_ON)]
    public static void ChannelLogCriticalFormat(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogCriticalFormat(channel, context, format, args);
    }

    /// <summary>
    /// Assert a condition, log a formatted error message to a channel for all Logger streams on failure and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>Channel.AssertFormat()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="condition">Condition you expect to be true.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelAssertFormat(string channel, bool condition, Object context, string format, params object[] args)
    {
        Logger.ChannelAssertFormat(channel, condition, context, format, args);
    }

    /// <summary>
    /// Log a formatted assertion message to a channel for all Logger streams and highlight in the hierarchy the object that the message applies to.
    ///
    /// Use <c>ChannelLogger.Assertion()</c> instead if you need more control over the channel.
    ///
    /// Note that this method works only if <c>LoggerProperty.IsAssertEnabled</c> is enabled. Otherwise this method and the calls to this method will be
    /// stripped out avoiding all impact in performance and build size.
    ///
    /// </summary>
    /// <param name="channel">Used to identify the source of a log message so messages can be filtered out.</param>
    /// <param name="context">Object to which the message applies.</param>
    /// <param name="format">A composite format string.</param>
    /// <param name="args">Format arguments.</param>
    [Conditional(HT_LOGGER_ASSERT_ON)]
    public static void ChannelLogAssertion(string channel, Object context, string format, params object[] args)
    {
        Logger.ChannelLogAssertion(channel, context, format, args);
    }

    [Conditional(DEBUG)]
    public static void Break()
    {
        UnityEngine.Debug.Break();
    }

    [Conditional(DEBUG)]
    public static void ClearDeveloperConsole()
    {
        UnityEngine.Debug.ClearDeveloperConsole();
    }

    public static string FormatTextInCodeContext(string text)
    {
        return $"<i>'{text}'</i>";
    }

    public static string FormatTextInUserContext(string text)
    {
        return $"<b>'{text}'</b>";
    }

    [Conditional(DEBUG)]
    public static void DrawLine(Vector3 start, Vector3 end)
    {
        UnityEngine.Debug.DrawLine(start, end);
    }

    [Conditional(DEBUG)]
    public static void DrawLine(Vector3 start, Vector3 end, Color color)
    {
        UnityEngine.Debug.DrawLine(start, end, color);
    }

    [Conditional(DEBUG)]
    public static void DrawLine(Vector3 start, Vector3 end, Color color, float duration)
    {
        UnityEngine.Debug.DrawLine(start, end, color, duration);
    }

    [Conditional(DEBUG)]
    public static void DrawLine(Vector3 start, Vector3 end, Color color, float duration, bool depthTest)
    {
        UnityEngine.Debug.DrawLine(start, end, color, duration, depthTest);
    }

    [Conditional(DEBUG)]
    public static void DrawRay(Vector3 start, Vector3 dir)
    {
        UnityEngine.Debug.DrawRay(start, dir);
    }

    [Conditional(DEBUG)]
    public static void DrawRay(Vector3 start, Vector3 dir, Color color)
    {
        UnityEngine.Debug.DrawRay(start, dir, color);
    }

    [Conditional(DEBUG)]
    public static void DrawRay(Vector3 start, Vector3 dir, Color color, float duration)
    {
        UnityEngine.Debug.DrawRay(start, dir, color, duration);
    }

    [Conditional(DEBUG)]
    public static void DrawRay(Vector3 start, Vector3 dir, Color color, float duration, bool depthTest)
    {
        UnityEngine.Debug.DrawRay(start, dir, color, duration, depthTest);
    }

#if UNITY_EDITOR
    /// <summary>
    /// Collection of methods that won't be stripped out. Use these methods for logging from inhouse Editor tools,
    /// </summary>
    /// <param name="msg"></param>
    #region editor
    public static void EditorLog(string msg)
    {
        UnityEngine.Debug.Log(msg);
    }

    public static void EditorLogFormat(string format, params object[] args)
    {
        EditorLog(string.Format(format, args));
    }

    public static void EditorLogWarning(string msg)
    {
        UnityEngine.Debug.LogWarning(msg);
    }

    public static void EditorLogError(string msg)
    {
        UnityEngine.Debug.LogError(msg);
    }

    public static void EditorLogErrorFormat(string format, params object[] args)
    {
        EditorLogError(string.Format(format, args));
    }
    #endregion
#endif
}