kreta/Framework/Logging/Logger.cs

using System;
using Kreta.Framework.Exceptions;
using Kreta.Framework.Security;

namespace Kreta.Framework.Logging
{
    /// <summary>
    /// A naplózható eseményeket kivezető osztály.
    /// </summary>
    /// <remarks>
    /// Célja, hogy tipizáltan egy helyre kivezesse az összes naplózandó 
    /// eseményt. Az osztály felelőssége, hogy a megfelelő naplóüzenetet 
    /// állítsa össze a naplózó számára.
    /// </remarks>
    public sealed class Logger
    {
        // <<Facade>>

        /// <summary>
        /// Naplózó segédobjektum
        /// </summary>
        private ILogWriter m_LogWriter;

        /// <summary>
        /// Az osztály konstruktora.
        /// </summary>
        /// <param name="logWriter">A naplózó, ahova dolgozik az objektum</param>
        public Logger(ILogWriter logWriter)
        {
            this.m_LogWriter = logWriter ?? throw new ArgumentNullException(nameof(logWriter));
        }

        /// <summary>
        /// A jelenleg használatos naplózó objektum.
        /// </summary>
        public static Logger Current
        {
            get
            {
                return SDAServer.Instance.Logger;
            }
        }

        /// <summary>
        /// A naplózó, ahova dolgozik az objektum.
        /// </summary>
        public ILogWriter LogWriter
        {
            get
            {
                return m_LogWriter;
            }
        }

        #region Belső dolgok

        /// <summary>
        /// Elvégzi egy naplóüzenet naplóba kerülését
        /// </summary>
        /// <param name="message">A naplózandó naplóüzenet</param>
        private Guid? Log(ILogMessage message)
        {
            if (message == null)
            {
                return null;
            }

            var logId = this.m_LogWriter.Log(message);
            message.IsLogged = true;
            return logId;
        }

        private static LogMessage CreateLogMessage(Events eventType, LogLevel logLevel)
        {
            // <<Factory Method>>
            return CreateLogMessage(eventType, logLevel, Guid.NewGuid().ToString());
        }

        private static LogMessage CreateLogMessage(Events eventType, LogLevel logLevel, string entryId)
        {
            // <<Factory Method>>
            LogMessage result = new LogMessage(entryId);
            result.EventType = eventType;
            result.Level = logLevel;

            UserContext usercontext = UserContext.Instance;
            if (usercontext != null)
            {
                result.UserId = usercontext.FelhasznaloId.ToString();
                result.SessionId = usercontext.SessionID;
            }
            else
            {
                result.UserId = "<unknown>";
            }

            return result;
        }

        #endregion

        #region Egyéb események

        /// <summary>
        /// Egyéb esemény történt.
        /// </summary>
        /// <remarks>Nem szabad használnunk!</remarks>
        public void GeneralEvent(LogLevel logLevel, string details)
        {
            LogMessage message = CreateLogMessage(Events.GENERAL, logLevel);
            message.SetParameter(LogParameter.DETAILS, details);
            this.Log(message);
        }

        /// <summary>
        /// Tetszőleges log esemény naplózása.
        /// </summary>
        /// <param name="oEvent">Esemény tipusa</param>
        /// <param name="oLogLevel">LogLevel</param>
        /// <param name="details">Részletek</param>
        public void CustomEvent(Kreta.Framework.Events oEvent, LogLevel oLogLevel, string details)
        {
            LogMessage message = CreateLogMessage(oEvent, oLogLevel);
            message.SetParameter(LogParameter.DETAILS, details);
            this.Log(message);
        }

        /// <summary>
        /// Egy Neptun behívás történt.
        /// </summary>
        public void NeptunConnectorEvent(string actionName, DateTime actionTime, string serverName)
        {
            LogMessage message = CreateLogMessage(Events.NEPTUN_CONNECTOR_EVENT, LogLevel.INFO);
            message.SetParameter(LogParameter.DETAILS,
                string.Format(
                    "A {0} nevű Neptun szerver {1}-kor egy {2} akciót indított.",
                    serverName,
                    actionTime,
                    actionName));
            this.Log(message);
        }

        /// <summary>
        /// A kiszolgáló terheltségét lekérdezték.
        /// </summary>
        /// <param name="serverLoad">A terheltség</param>
        public void ServerLoad(double serverLoad)
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVERLOAD, LogLevel.INFO);
            message.SetParameter(LogParameter.SERVERLOAD, serverLoad.ToString());
            this.Log(message);
        }

        /// <summary>
        /// Hibás FDL szűrő.
        /// </summary>
        /// <param name="sqlText">A szűrőben definiált SQL töredék.</param>
        public void BadFDL(string sqlText)
        {
            LogMessage message = CreateLogMessage(Events.FDL_BAD_FILTER, LogLevel.WARNING);
            message.SetParameter(LogParameter.SQLTEXT, sqlText);
            this.Log(message);
        }

        #endregion

        #region Kiszolgáló eseményei

        /// <summary>
        /// A konfiguráció sikeresen betöltődött.
        /// </summary>
        public void ConfigurationLoaded()
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_CONFIGLOADED, LogLevel.DEBUG);
            this.Log(message);
        }

        /// <summary>
        /// A kiszolgáló elindult.
        /// </summary>
        public void ServerStarted()
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVERSTART, LogLevel.INFO);
            message.SetParameter(LogParameter.DETAILS, string.Format("Machine Name: {0}", Environment.MachineName));
            this.Log(message);
        }

        /// <summary>
        /// A kiszolgáló leállt.
        /// </summary>
        public void ServerStopped()
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVERSTOP, LogLevel.INFO);
            System.Diagnostics.StackTrace stacktrace = new System.Diagnostics.StackTrace(); // XXX
            message.SetParameter(LogParameter.STACKTRACE, stacktrace.ToString()); // XXX
            this.Log(message);
        }

        /// <summary>
        /// A kiszolgáló külső leállítási kérelmet kapott.
        /// </summary>
        public void ServerStopping()
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_SERVER_STOPPING, LogLevel.INFO);
            message.SetParameter(LogParameter.DETAILS, "Külső leállítási kérelem folyamatban.");
            this.Log(message);
        }

        #endregion

        #region Munkamenet kezelés eseményei

        /// <summary>
        /// Az összes munkamenet meg lett szüntetve.
        /// </summary>
        /// <param name="successful">Sikeres volt-e</param>
        public void SessionCleanup(bool successful)
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_SESSIONCLEANUP, LogLevel.INFO);
            message.SetParameter(LogParameter.SUCCESSFUL, successful.ToString());
            this.Log(message);
        }

        public void LoginSuccess(LoginInfo info)
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_USER_LOGIN, LogLevel.INFO);
            message.SessionId = info.SessionID;
            message.SetParameter(LogParameter.USERID, info.FelhasznaloId);
            message.SetParameter(LogParameter.USERNAME, info.BelepesiNev);
            message.SetParameter(LogParameter.CLIENTIP, info.ClientIP);
            message.SetParameter(LogParameter.INTEZMENYID, info.IntezmenyId);
            message.SetParameter(LogParameter.TANEVID, info.AktivTanevId);
            this.Log(message);
        }

        /// <summary>
        /// A munkamenet meg lett szűntetve.
        /// </summary>
        /// <param name="sessionId">A munkamenet azonosítója</param>
        public void SessionDeleted(string sessionId)
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_SESSIONDELETED, LogLevel.INFO);
            message.SessionId = sessionId;
            this.Log(message);
        }

        /// <summary>
        /// A munkamenet lejárt és meg lett szűntetve.
        /// </summary>
        /// <param name="sessionId">A munkamenet azonosítója</param>
        public void SessionExpired(string sessionId)
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_SESSIONEXPIRED, LogLevel.INFO);
            message.SessionId = sessionId;
            this.Log(message);
        }

        #endregion

        #region Kivételkezelés eseményei

        #region Kliens
        /// <summary>
        /// Kliensen történt kivétel
        /// </summary>
        /// <param name="_details">A kivétel leírása és körülményei</param>
        public void ClientExceptionThrown(string _details)
        {
            LogMessage message = CreateLogMessage(Events.CLIENT_GENERAL, LogLevel.ERROR);
            message.SetParameter(LogParameter.DETAILS, _details);
            if (UserContext.Instance != null)
            {
                message.SetParameter(LogParameter.CONTEXT_INFO, UserContext.Instance.ToString());
            }
            this.Log(message);
        }
        #endregion

        /// <summary>
        /// Kivétel történt.
        /// </summary>
        /// <param name="exception">A naplózandó kivétel</param>
        public Guid? ExceptionThrown(FrameworkException exception)
        {
            if (exception == null || exception.IsLogged)
            {
                return null;
            }

            LogMessage message = CreateLogMessage((Events)exception.ClientErrorCode, exception.LogLevel, exception.Id);
            message.SetParameter(LogParameter.DETAILS, ExceptionUtil.ExceptionToString(exception));
            if (UserContext.Instance != null)
            {
                message.SetParameter(LogParameter.CONTEXT_INFO, UserContext.Instance.ToString());
            }
            else
            {
                if (exception.Data.Contains(LogParameter.SESSIONID))
                {
                    object obj = exception.Data[LogParameter.SESSIONID];
                    if (obj.GetType() == typeof(string))
                    {
                        message.SessionId = (string)obj;
                    }
                }
            }
            var logId = this.Log(message);
            exception.SetLogged();
            return logId;
        }

        /// <summary>
        /// Kivétel történt.
        /// </summary>
        /// <param name="exception">A naplózandó kivétel</param>
        public Guid? ExceptionThrown(Exception exception)
        {
            return ExceptionThrown(exception, null);
        }

        /// <summary>
        /// Kivétel történt.
        /// </summary>
        /// <param name="exception">A naplózandó kivétel</param>
        /// <param name="clientIP">Az ügyfél IP-címe</param>
        public Guid? ExceptionThrown(Exception exception, string clientIP)
        {
            FrameworkException frameworkexception = exception as FrameworkException;
            if (frameworkexception != null)
            {
                return ExceptionThrown(frameworkexception);
            }

            if (exception != null && !object.Equals(exception.Data["$IsLogged"], true))
            {
                LogMessage message = CreateLogMessage(Events.SYSTEM_EXCEPTION, LogLevel.ERROR);
                message.SetParameter(LogParameter.DETAILS, ExceptionUtil.ExceptionToString(exception));
                if (clientIP != null)
                {
                    message.SetParameter(LogParameter.CLIENTIP, clientIP);
                }
                if (UserContext.Instance != null)
                {
                    message.SetParameter(LogParameter.CONTEXT_INFO, UserContext.Instance.ToString());
                }
                var logId = this.Log(message);
                exception.Data["$IsLogged"] = true;
                return logId;
            }

            return null;
        }

        #endregion

        #region Akciók eseményei

        /// <summary>
        /// Akció meghívása történt.
        /// </summary>
        /// <param name="actionName">Az akció neve</param>
        public void ActionExecuted(string actionName)
        {
            LogMessage message = CreateLogMessage(Events.ACTION_EXECUTE, LogLevel.DEBUG);
            message.SetParameter(LogParameter.OPERATIONNAME, actionName);
            this.Log(message);
        }

        #endregion

        #region Entitások eseményei

        /// <summary>
        /// Nem sikerült naplóznunk egy entitás történelmét.
        /// </summary>
        /// <param name="entityId">Az entitás azonosítója</param>
        /// <param name="entityName">Az entitás neve</param>
        public void SaveEntityHistoryFailed(int entityId, string entityName)
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_ENTITYHISTORYFAILED, LogLevel.ERROR);
            message.SetParameter(LogParameter.ENTITYID, entityId);
            message.SetParameter(LogParameter.ENTITYNAME, entityName);
            this.Log(message);
        }

        #endregion

        #region Adatbáziskezelés eseményei

        /// <summary>
        /// Ügylet kezdete.
        /// </summary>
        public void BeginTransaction()
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_BEGINTRANSACTION, LogLevel.INFO);
            this.Log(message);
        }

        /// <summary>
        /// Ügylet vége jóváhagyással.
        /// </summary>
        public void CommitTransaction()
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_COMMITTRANSACTION, LogLevel.INFO);
            this.Log(message);
        }

        /// <summary>
        /// Ügylet vége visszagörgetéssel.
        /// </summary>
        public void RollbackTransaction()
        {
            LogMessage message = CreateLogMessage(Events.FRAMEWORK_ROLLBACKTRANSACTION, LogLevel.INFO);
            this.Log(message);
        }

        /// <summary>
        /// SQL utasítás lett végrehajtva.
        /// </summary>
        /// <param name="sqlText">Végrehajtandó SQL utasítás</param>
        /// <remarks>Sorszurt SQL utasításra célszeru használni.</remarks>
        public void SQLExecuted(string sqlText)
        {
            LogMessage message = CreateLogMessage(Events.SQL_EXECUTED, LogLevel.DEBUG);
            message.SetParameter(LogParameter.SQLTEXT, sqlText);
            this.Log(message);
        }

        #endregion
    }
}