log4net Levels im laufenden Betrieb ändern

Home » Dev » log4net Levels im laufenden Betrieb ändern

log4net Levels im laufenden Betrieb ändern

3. Juli 2013

div class=“articleAbstract“>

Entwicklerteams, die Logging schon zur Entwicklungszeit ausgiebig nutzen, haben es sehr leicht Fehler in der laufenden Produktionsumgebung zu analysieren. Man muss nur kurz den Loglevel hochsetzen, wenn – ja wenn – man Zugriff auf die Konfigurationsdatei hat. In großen Produktionsumgebungen ist dies üblicherweise nicht erlaubt.

Mit ein bisschen Programmierung kann man die Loglevels für log4net im laufenden Betrieb auf einer Admin-Seite anzeigen und ein- bzw. ausschalten (toggeln). Ein exemplarisches Userinterface – hier als ASP.NET User Control realisiert – sieht im Ergebnis wie folgt aus:

ASP.NET Beispiel-Userinterface

Funktionsweise (Business Logic)

LogLevels

In log4net kann ein Logger genau einen Level haben. In der obigen Grafik zum Userinterface ist der Level für den Logger “MyApp.Log1” auf “Error” gesetzt. Dadurch ergibt sich automatisch, dass die Level “Info” und “Debug” deaktiviert und “Fatal” aktiviert sind.

Aktivieren: Wird ein Level von deaktiviert in aktiviert geändert, so wird der Level direkt am Logger gesetzt. Beispiel: Klicken von “IsDebug” des Loggers “MyApp.Log1” setzt den Level “Debug” des Loggers.
Deaktivieren: Wird ein Level deaktiviert, so wird der nächste höhere Level aktiviert. Beispiel: Klicken auf “IsError” des Loggers “MyApp.Log1” setzt den Level des Loggers auf “Fatal”.

Somit kann jede gewünschte Logging-Stufe direkt ein- und ausgeschaltet werden.

Defining Logger

Mit dem Interface ILog der Logger können die Informationen zu IsFatal, IsError etc. ermittelt werden. Theoretisch kann für jeden Logger ein eigener LogLevel definiert werden. In der Praxis wird man sich jedoch darauf beschränken den Level nur für den Root-Logger oder wenige andere anwendungsrelevante Logger zu setzen, deren Werte sich auf alle Kinder vererben. Die Vererbung wird im Userinterface in der Spalte “Defining Logger” angezeigt. Beispiel: Wird der Level für “MyApp.Log1.Sub11” geändert, so ändert sich auch der geerbte Wert für den Logger “MyApp.Log1.Sub11.Sub111”

Code

Der Code besteht aus zwei Methoden. Die erste Methode GetLoggerInformation() ermittelt den Zustand aller Logger. Die zweite Methode ToggleLogLevel() schaltet den Zustand eines LogLevels anhand der vorgestellten Business Logic um.

namespace Sdx.Logging      
{      
    using log4net;      
    using log4net.Core;      
    using System.Linq;      
    using System.Collections.Generic;      
       
    /// <summary>      
    /// Helper class, to retrieve all loggers and toggle levels      
    /// </summary>      
    public class LogLevelToggler      
    {      
        /// <summary>      
        /// Retrieve current Logger information      
        /// </summary>      
        /// <returns></returns>      
        public List<LoggerInformation> GetLoggerInformation()      
        {      
            var result = new List<LoggerInformation>();      
       
            // if you like to care about repositories, feel free to modify      
            // get ILog interfaces of all loggers      
            foreach (var repository in LogManager.GetAllRepositories())      
            {      
                var loggers = repository.GetCurrentLoggers();      
                foreach (var l in loggers)      
                {      
                    // Add Logging information      
                    var li = new LoggerInformation      
                        {      
                            Name = l.Name,      
                            Repository =  repository.Name,      
                            IsFatal = l.IsEnabledFor(Level.Fatal),      
                            IsError = l.IsEnabledFor(Level.Error),      
                            IsInfo = l.IsEnabledFor(Level.Info),      
                            IsDebug = l.IsEnabledFor(Level.Debug),      
                        };      
                    result.Add(li);      
       
                    // enrich hierarchie information      
                    var hierarchieLogger = l as log4net.Repository.Hierarchy.Logger;      
                    if (hierarchieLogger != null)      
                    {      
                        // get defining logger for level      
                        while (hierarchieLogger.Level == null && hierarchieLogger.Parent != null)      
                        {      
                            hierarchieLogger = hierarchieLogger.Parent;      
                        }      
                        li.DefiningLogger = hierarchieLogger.Name;      
                    }      
                    else      
                    {      
                        // fallback      
                        li.DefiningLogger = "-- unknown --";      
                    }      
                }      
            }      
            return result;      
        }      
       
        /// <summary>      
        /// Supported Levels      
        /// </summary>      
        public static readonly Dictionary<string, Level> LevelMap = new Dictionary<string, Level>      
        {      
            {"IsOff", Level.Off },      
            {"IsFatal", Level.Fatal},      
            {"IsError", Level.Error},      
            {"IsInfo", Level.Info},      
            {"IsDebug", Level.Debug},      
            {"IsAll", Level.All},      
        };      
       
       
        /// <summary>      
        /// Toggle level for logger       
        /// </summary>      
        /// <param name="loggerName">name of logger</param>      
        /// <param name="selectedLevel">level to toggle</param>      
        public void ToggleLogLevel(string loggerName, Level selectedLevel)      
        {      
            // get Logger interface      
            var logger = log4net.LogManager.GetLogger(loggerName);      
            if (logger != null)      
            {      
                // get hierachical logger      
                var hl = logger.Logger as log4net.Repository.Hierarchy.Logger;      
                if (hl != null)      
                {      
                    if (hl.EffectiveLevel <= selectedLevel)      
                    {      
                             
                        // Disable Selected Level by selecting Level + 1      
                        // eg. disable INFO by setting level to ERROR      
                        hl.Level = LogLevelToggler.LevelMap.TakeWhile(l => l.Value != selectedLevel).Last().Value;       
                    }      
                    else      
                    {      
                        // Enable Selected Level      
                        hl.Level = selectedLevel;      
                    }      
                }      
            }      
        }      
    }      
}

Business Logic: LogLevelToggler

namespace Sdx.Logging      
{      
    /// <summary>      
    /// Display object      
    /// </summary>      
    public class LoggerInformation      
    {      
        // Name of Logger      
        public string Name { get; set; }      
        public string Repository { get; set; }      
        
        // Levels      
        public bool IsFatal { get; set; }      
        public bool IsError { get; set; }      
        public bool IsInfo { get; set; }      
        public bool IsDebug { get; set; }      
              
        // Name of logger, defining the Level      
        public string DefiningLogger { get; set; }      
    }      
}

Value Object: LoggerInformation

Ausblick

Das zugehörige ASP.NET Control zum bequemen Einbinden in eigene Projekte habe ich im folgenden Beitrag veröffentlicht. Eine Einbindung in eine Admin-Seite (!) ist dann schnell durchgeführt. Viel Spaß mit dem kleinen Helferlein.