Example #1
0
            private static bool Initialize()
            {
                try
                {
                    var logEventLevelType = FindType("NLog.LogLevel", "NLog");
                    if (logEventLevelType == null)
                    {
                        throw new LibLogException("Type NLog.LogLevel was not found.");
                    }

                    var levelFields = logEventLevelType.GetFields().ToList();
                    s_levelTrace = levelFields.First(x => x.Name == "Trace").GetValue(null);
                    s_levelDebug = levelFields.First(x => x.Name == "Debug").GetValue(null);
                    s_levelInfo  = levelFields.First(x => x.Name == "Info").GetValue(null);
                    s_levelWarn  = levelFields.First(x => x.Name == "Warn").GetValue(null);
                    s_levelError = levelFields.First(x => x.Name == "Error").GetValue(null);
                    s_levelFatal = levelFields.First(x => x.Name == "Fatal").GetValue(null);

                    var logEventInfoType = FindType("NLog.LogEventInfo", "NLog");
                    if (logEventInfoType == null)
                    {
                        throw new LibLogException("Type NLog.LogEventInfo was not found.");
                    }

                    var loggingEventConstructor =
                        logEventInfoType.GetConstructorPortable(logEventLevelType, typeof(string),
                                                                typeof(IFormatProvider), typeof(string), typeof(object[]), typeof(Exception));

                    var loggerNameParam  = Expression.Parameter(typeof(string));
                    var levelParam       = Expression.Parameter(typeof(object));
                    var messageParam     = Expression.Parameter(typeof(string));
                    var messageArgsParam = Expression.Parameter(typeof(object[]));
                    var exceptionParam   = Expression.Parameter(typeof(Exception));
                    var levelCast        = Expression.Convert(levelParam, logEventLevelType);

                    var newLoggingEventExpression =
                        Expression.New(loggingEventConstructor,
                                       levelCast,
                                       loggerNameParam,
                                       Expression.Constant(null, typeof(IFormatProvider)),
                                       messageParam,
                                       messageArgsParam,
                                       exceptionParam
                                       );

                    s_logEventInfoFact = Expression.Lambda <Func <string, object, string, object[], Exception, object> >(
                        newLoggingEventExpression,
                        loggerNameParam, levelParam, messageParam, messageArgsParam, exceptionParam).Compile();

                    var loggerType = FindType("NLog.Logger", "NLog");

                    s_loggerNameDelegate = GetLoggerNameDelegate(loggerType);

                    s_logEventDelegate = GetLogEventDelegate(loggerType, logEventInfoType);

                    s_isTraceEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsTraceEnabled");
                    s_isDebugEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsDebugEnabled");
                    s_isInfoEnabledDelegate  = GetIsEnabledDelegate(loggerType, "IsInfoEnabled");
                    s_isWarnEnabledDelegate  = GetIsEnabledDelegate(loggerType, "IsWarnEnabled");
                    s_isErrorEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsErrorEnabled");
                    s_isFatalEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsFatalEnabled");

                    s_traceDelegate = GetLogDelegate(loggerType, "Trace");
                    s_debugDelegate = GetLogDelegate(loggerType, "Debug");
                    s_infoDelegate  = GetLogDelegate(loggerType, "Info");
                    s_warnDelegate  = GetLogDelegate(loggerType, "Warn");
                    s_errorDelegate = GetLogDelegate(loggerType, "Error");
                    s_fatalDelegate = GetLogDelegate(loggerType, "Fatal");

                    s_traceExceptionDelegate = GetLogExceptionDelegate(loggerType, "TraceException");
                    s_debugExceptionDelegate = GetLogExceptionDelegate(loggerType, "DebugException");
                    s_infoExceptionDelegate  = GetLogExceptionDelegate(loggerType, "InfoException");
                    s_warnExceptionDelegate  = GetLogExceptionDelegate(loggerType, "WarnException");
                    s_errorExceptionDelegate = GetLogExceptionDelegate(loggerType, "ErrorException");
                    s_fatalExceptionDelegate = GetLogExceptionDelegate(loggerType, "FatalException");

                    s_structuredLoggingEnabled = IsStructuredLoggingEnabled();
                }
                catch (Exception ex)
                {
                    s_initializeException = ex;
                    return(false);
                }

                return(true);
            }
Example #2
0
            static NLogLogger()
            {
                try
                {
                    var logEventLevelType = Type.GetType("NLog.LogLevel, NLog");
                    if (logEventLevelType == null)
                    {
                        throw new InvalidOperationException("Type NLog.LogLevel was not found.");
                    }

                    var levelFields = logEventLevelType.GetFields().ToList();
                    _levelTrace = levelFields.First(x => x.Name == "Trace").GetValue(null);
                    _levelDebug = levelFields.First(x => x.Name == "Debug").GetValue(null);
                    _levelInfo  = levelFields.First(x => x.Name == "Info").GetValue(null);
                    _levelWarn  = levelFields.First(x => x.Name == "Warn").GetValue(null);
                    _levelError = levelFields.First(x => x.Name == "Error").GetValue(null);
                    _levelFatal = levelFields.First(x => x.Name == "Fatal").GetValue(null);

                    var logEventInfoType = Type.GetType("NLog.LogEventInfo, NLog");
                    if (logEventInfoType == null)
                    {
                        throw new InvalidOperationException("Type NLog.LogEventInfo was not found.");
                    }

                    var loggingEventConstructor = logEventInfoType.GetConstructor(new []
                    {
                        logEventLevelType,
                        typeof(string),
                        typeof(IFormatProvider),
                        typeof(string),
                        typeof(object[]),
                        typeof(Exception),
                    });
                    ParameterExpression loggerNameParam  = Expression.Parameter(typeof(string));
                    ParameterExpression levelParam       = Expression.Parameter(typeof(object));
                    ParameterExpression messageParam     = Expression.Parameter(typeof(string));
                    ParameterExpression messageArgsParam = Expression.Parameter(typeof(object[]));
                    ParameterExpression exceptionParam   = Expression.Parameter(typeof(Exception));
                    UnaryExpression     levelCast        = Expression.Convert(levelParam, logEventLevelType);

                    NewExpression newLoggingEventExpression =
                        Expression.New(loggingEventConstructor,
                                       levelCast,
                                       loggerNameParam,
                                       Expression.Constant(null, typeof(IFormatProvider)),
                                       messageParam,
                                       messageArgsParam,
                                       exceptionParam
                                       );

                    _logEventInfoFact = Expression.Lambda <Func <string, object, string, object[], Exception, object> >(
                        newLoggingEventExpression,
                        loggerNameParam, levelParam, messageParam, messageArgsParam, exceptionParam).Compile();

                    Type loggerType = Type.GetType("NLog.Logger, NLog");

                    _loggerNameDelegate = GetLoggerNameDelegate(loggerType);

                    _logEventDelegate = GetLogEventDelegate(loggerType, logEventInfoType);

                    _isTraceEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsTraceEnabled");
                    _isDebugEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsDebugEnabled");
                    _isInfoEnabledDelegate  = GetIsEnabledDelegate(loggerType, "IsInfoEnabled");
                    _isWarnEnabledDelegate  = GetIsEnabledDelegate(loggerType, "IsWarnEnabled");
                    _isErrorEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsErrorEnabled");
                    _isFatalEnabledDelegate = GetIsEnabledDelegate(loggerType, "IsFatalEnabled");

                    _traceDelegate = GetLogDelegate(loggerType, "Trace");
                    _debugDelegate = GetLogDelegate(loggerType, "Debug");
                    _infoDelegate  = GetLogDelegate(loggerType, "Info");
                    _warnDelegate  = GetLogDelegate(loggerType, "Warn");
                    _errorDelegate = GetLogDelegate(loggerType, "Error");
                    _fatalDelegate = GetLogDelegate(loggerType, "Fatal");

                    _traceExceptionDelegate = GetLogExceptionDelegate(loggerType, "TraceException");
                    _debugExceptionDelegate = GetLogExceptionDelegate(loggerType, "DebugException");
                    _infoExceptionDelegate  = GetLogExceptionDelegate(loggerType, "InfoException");
                    _warnExceptionDelegate  = GetLogExceptionDelegate(loggerType, "WarnException");
                    _errorExceptionDelegate = GetLogExceptionDelegate(loggerType, "ErrorException");
                    _fatalExceptionDelegate = GetLogExceptionDelegate(loggerType, "FatalException");

                    _structuredLoggingEnabled = IsStructuredLoggingEnabled();
                }
                catch { }
            }