/// <summary> /// Processes the log messages. /// </summary> /// <param name="events">The events to process.</param> public void ProcessLogMessages(NLogEvents events) { var baseTimeUtc = new DateTime(events.BaseTimeUtc, DateTimeKind.Utc); var logEvents = new LogEventInfo[events.Events.Length]; // convert transport representation of log events into workable LogEventInfo[] for (int j = 0; j < events.Events.Length; ++j) { var ev = events.Events[j]; LogLevel level = LogLevel.FromOrdinal(ev.LevelOrdinal); string loggerName = events.Strings[ev.LoggerOrdinal]; var logEventInfo = new LogEventInfo(); logEventInfo.Level = level; logEventInfo.LoggerName = loggerName; logEventInfo.TimeStamp = baseTimeUtc.AddTicks(ev.TimeDelta); logEventInfo.Message = events.Strings[ev.MessageOrdinal]; logEventInfo.Properties.Add("ClientName", events.ClientName); for (int i = 0; i < events.LayoutNames.Count; ++i) { logEventInfo.Properties.Add(events.LayoutNames[i], events.Strings[ev.ValueIndexes[i]]); } logEvents[j] = logEventInfo; } this.ProcessLogMessages(logEvents); }
/// <summary> /// Enables logging for a particular levels between (included) <paramref name="minLevel"/> and <paramref name="maxLevel"/>. /// </summary> /// <param name="minLevel">Minimum log level needed to trigger this rule.</param> /// <param name="maxLevel">Maximum log level needed to trigger this rule.</param> public void EnableLoggingForLevels(LogLevel minLevel, LogLevel maxLevel) { for (int i = minLevel.Ordinal; i <= maxLevel.Ordinal; ++i) { this.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } }
protected override void Write(LogEventInfo logEvent) { if (!_client.Configuration.IsValid) { return; } LogLevel minLogLevel = LogLevel.FromOrdinal(_client.Configuration.Settings.GetMinLogLevel(logEvent.LoggerName).Ordinal); if (logEvent.Level < minLogLevel) { return; } var builder = _client.CreateFromLogEvent(logEvent); foreach (var field in Fields) { var renderedField = field.Layout.Render(logEvent); if (!String.IsNullOrWhiteSpace(renderedField)) { builder.AddObject(renderedField, field.Name); } } builder.Submit(); }
/// <summary> /// Reconfigures the NLog logging level. /// </summary> /// <param name="level">The <see cref="LogLevel" /> to be set.</param> private static void SetNlogLogLevel(LogLevel level) { if (level == LogLevel.Off) { LogManager.DisableLogging(); } else { if (!LogManager.IsLoggingEnabled()) { LogManager.EnableLogging(); } foreach (var rule in LogManager.Configuration.LoggingRules) { // Iterate over all levels up to and including the target, (re)enabling them. for (int i = level.Ordinal; i <= 5; i++) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } } } LogManager.ReconfigExistingLoggers(); }
private void Log(LogEventModel logEventModel) { var logEvent = new LogEventInfo { Level = LogLevel.FromOrdinal((int)logEventModel.Level), LoggerName = logEventModel.LoggerSource, Message = logEventModel.Message, TimeStamp = logEventModel.TimeStamp }; logEvent.Properties["ApplicationName"] = logEventModel.ApplicationName; logEvent.Properties["CorrelationId"] = logEventModel.CorrelationId; logEvent.Properties["MachineName"] = logEventModel.MachineName; logEvent.Properties["MicroserviceName"] = logEventModel.MicroserviceName; logEvent.Properties["Exception"] = logEventModel.Exception; var properties = logEventModel.CustomProperties as JObject; if (properties != null) { foreach (var property in properties.Properties()) { logEvent.Properties[property.Name] = property.Value; } } _logger.Log(logEvent); }
private static void SetupLogging() { var settingsService = new SettingsServiceV2 <LogSettings>(new SettingsJsonRepository(new DbConfiguration(new SqliteFactory()), new MemoryCacheProvider())); var logSettings = settingsService.GetSettings(); LoggingHelper.ReconfigureLogLevel(logSettings != null ? LogLevel.FromOrdinal(logSettings.Level) : LogLevel.FromOrdinal(4)); }
private static void TestMinLevelSwitch_inner(string rawLogLevel, int count, Action log) { try { //set minimal InternalLogger.LogLevel = LogLevel.FromString(rawLogLevel); InternalLogger.IncludeTimestamp = false; StringWriter consoleOutWriter = new StringWriter() { NewLine = ";" }; InternalLogger.LogWriter = consoleOutWriter; var expected = ""; var logLevel = LogLevel.Fatal.Ordinal; for (int i = 0; i < count; i++, logLevel--) { expected += LogLevel.FromOrdinal(logLevel) + " L" + (i + 1) + ";"; } log(); var strings = consoleOutWriter.ToString(); Assert.Equal(expected, strings); } finally { InternalLogger.Reset(); } }
public void LogLevelFromOrdinal_InputOutOfRange_ExpectException() { Assert.Throws <ArgumentException>(() => LogLevel.FromOrdinal(100)); // Boundary conditions. Assert.Throws <ArgumentException>(() => LogLevel.FromOrdinal(-1)); Assert.Throws <ArgumentException>(() => LogLevel.FromOrdinal(7)); }
private Response UpdateLogLevels(int level) { var newLevel = LogLevel.FromOrdinal(level); LoggingHelper.ReconfigureLogLevel(newLevel); return(Response.AsJson(new JsonResponseModel { Result = true, Message = $"The new log level is now {newLevel}" })); }
/// <summary> /// Initializes a new instance of <see cref="LoggingRule"/> by /// setting the logger name pattern, minimum logging level and /// the target to be written to when logger name and log level match. /// </summary> /// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param> /// <param name="minLevel">Minimum log level needed to trigger this rule.</param> /// <param name="target">Target to be written to when the rule matches.</param> public LoggingRule(string loggerNamePattern, LogLevel minLevel, Target target) { LoggerNamePattern = loggerNamePattern; _targets.Add(target); for (int i = (int)minLevel.Ordinal; i <= (int)LogLevel.MaxLevel.Ordinal; ++i) { EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } }
/// <summary> /// Writes the diagnostic message at the specified level. /// </summary> /// <param name="ordinal">Ordinal of the log level.</param> /// <param name="message">Log message.</param> public void Log(int ordinal, string message) { if (ordinal < LogLevel.Trace.Ordinal || ordinal > LogLevel.Off.Ordinal) { logger.Warn("Invalid ordinal level. Logger level is Off"); ordinal = LogLevel.Off.Ordinal; } logger.Log(LogLevel.FromOrdinal(ordinal), message); }
public void LogLevelFromOrdinal_InputInRange_ExpectValidLevel() { Assert.Same(LogLevel.FromOrdinal(0), LogLevel.Trace); Assert.Same(LogLevel.FromOrdinal(1), LogLevel.Debug); Assert.Same(LogLevel.FromOrdinal(2), LogLevel.Info); Assert.Same(LogLevel.FromOrdinal(3), LogLevel.Warn); Assert.Same(LogLevel.FromOrdinal(4), LogLevel.Error); Assert.Same(LogLevel.FromOrdinal(5), LogLevel.Fatal); Assert.Same(LogLevel.FromOrdinal(6), LogLevel.Off); }
public void TruncatedMessagesShouldBeWrittenAtCorrenpondingNLogLevel(int logLevelOrdinal, EventLogEntryType expectedEventLogEntryType, string expectedMessage, string layoutString) { LogLevel logLevel = LogLevel.FromOrdinal(logLevelOrdinal); Layout entryTypeLayout = layoutString != null ? new SimpleLayout(layoutString) : null; var eventRecords = WriteWithMock(logLevel, expectedEventLogEntryType, expectedMessage, entryTypeLayout).ToList(); Assert.Single(eventRecords); AssertWrittenMessage(eventRecords, expectedMessage); }
/// <summary> /// Instantiates an instance of <see cref="ILogger"/>. /// </summary> /// <returns>A <see cref="ILogger"/> instance resolved by one of the <see cref="IServiceLocator"/>s, otherwise a <see cref="NullLogger"/> or <see cref="NLogLogger"/> (leveraging the <see href="http://nlog-project.org/">NLog</see> project) based on configuration settings.</returns> public ILogger InstantiateLogger() { // reuse logger if already created if (Logger != null) { return(Logger); } ILogger result; if (TrySingleInstanceFromServiceLocators(out result)) { Logger = result; return(Logger); } // use null logger if logging is off var logLevel = Configuration.Logging.Level; if (logLevel == LoggingLevel.Off) { Logger = new NullLogger(); return(Logger); } var configuredPath = Configuration.Logging.LogLocation; // Root the path if it isn't already var logDirPath = Path.IsPathRooted(configuredPath) ? configuredPath : Path.Combine(AppDomain.CurrentDomain.BaseDirectory, configuredPath); // Add a filename if one isn't specified var logFilePath = string.IsNullOrEmpty(Path.GetExtension(logDirPath)) ? Path.Combine(logDirPath, "Glimpse.log") : logDirPath; // use NLog logger otherwise var fileTarget = new FileTarget { FileName = logFilePath, Layout = "${longdate} | ${level:uppercase=true} | ${message} | ${exception:maxInnerExceptionLevel=5:format=type,message,stacktrace:separator=--:innerFormat=shortType,message,method:innerExceptionSeparator=>>}" }; var asyncTarget = new AsyncTargetWrapper(fileTarget); var loggingConfiguration = new LoggingConfiguration(); loggingConfiguration.AddTarget("file", asyncTarget); loggingConfiguration.LoggingRules.Add(new LoggingRule("*", LogLevel.FromOrdinal((int)logLevel), asyncTarget)); Logger = new NLogLogger(new LogFactory(loggingConfiguration).GetLogger("Glimpse")); return(Logger); }
private void onSReceived(object sender, Message e) { Log._.NLog.Log ( LogLevel.FromOrdinal ( (int)(e.type == Message.Level.Info ? Message.Level.Debug : e.type) ), $"{nameof(MvsSln)}: {e.content}" ); }
public static LogLevel ToNLog(this LogLevelValue value) { if ((int)value < LogLevel.Trace.Ordinal || (int)value > LogLevel.Fatal.Ordinal) { throw new ArgumentOutOfRangeException( $"{nameof(value)}", $"{(int)value} is out of range [Trace={LogLevel.Trace.Ordinal}, Fatal={LogLevel.Fatal.Ordinal}]"); } return(LogLevel.FromOrdinal((int)value)); }
private void MetroWindow_Loaded_1(object sender, RoutedEventArgs e) { var textbox = new TextBoxTarget(OutputText) { Layout = @"[${date:format=h\:mm\:ss.ff tt}] [${level:uppercase=true}] ${message}" }; var asyncWrapper = new AsyncTargetWrapper(textbox); LogManager.Configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.FromOrdinal(UserPreferences.Default.LogLevel), asyncWrapper)); LogManager.ReconfigExistingLoggers(); }
private void onLSenderSent(object sender, Components.Message e) { Log._.NLog.Log ( LogLevel.FromOrdinal ( (int)(e.level == Components.MsgLevel.Info ? Components.MsgLevel.Debug : e.level) ), $"{sender.GetType().Name}: {e.content}" ); }
private static IEnumerable <LogLevel> GetLogLevels() { var logLevels = new List <LogLevel>(); logLevels.Add(LogLevel.Off); for (int logLevelOrdinal = 0; logLevelOrdinal <= 5; logLevelOrdinal++) { logLevels.Add(LogLevel.FromOrdinal(logLevelOrdinal)); } return(logLevels); }
/// <summary> /// Initializes a new instance of the <see cref="LoggingRule" /> class. /// </summary> /// <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param> /// <param name="minLevel">Minimum log level needed to trigger this rule.</param> /// <param name="target">Target to be written to when the rule matches.</param> public LoggingRule(string loggerNamePattern, LogLevel minLevel, Target target) { this.Filters = new List <Filter>(); this.ChildRules = new List <LoggingRule>(); this.Targets = new List <Target>(); this.LoggerNamePattern = loggerNamePattern; this.Targets.Add(target); for (int i = minLevel.Ordinal; i <= LogLevel.MaxLevel.Ordinal; ++i) { this.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } }
public DesignerLoggerViewModel() { var rnd = new Random(); LogEvents = new ObservableCollection <LogEventInfo>(); for (int i = 0; i < 100; i++) { LogEvents.Add(new LogEventInfo(LogLevel.FromOrdinal(rnd.Next(1, 5)), "Test", "Log test " + i)); } LogLevels = new List <string> (new[] { "Trace", "Debug", "Info", "Warn", "Error" }); _selectedLogLevel = "Trace"; }
private static void LogIt(int severity, string message) { StackTrace st = new StackTrace(); StackFrame x = st.GetFrame(2); //the third one goes back to the original caller Type t = x.GetMethod().DeclaringType; Logger theLogger = LogManager.GetLogger(t.FullName); //https://github.com/NLog/NLog/wiki/Log-levels string[] levels = { "Off", "Trace", "Debug", "Info", "Warn", "Error", "Fatal" }; int level = Math.Min(levels.Length, severity); theLogger.Log(LogLevel.FromOrdinal(level), message); }
[InlineData(2, EventLogEntryType.Information, "wrong entry type level")] // AtSpecifiedNLogLevel_WhenWrongEntryTypeLayoutSupplied public void SplitMessagesShouldBeWrittenAtCorrenpondingNLogLevel(int logLevelOrdinal, EventLogEntryType expectedEventLogEntryType, string layoutString) { LogLevel logLevel = LogLevel.FromOrdinal(logLevelOrdinal); Layout entryTypeLayout = layoutString != null ? new SimpleLayout(layoutString) : null; const int expectedEntryCount = 2; string messagePart1 = string.Join("", Enumerable.Repeat("l", MaxMessageLength)); string messagePart2 = "this part must be split"; string testMessage = messagePart1 + messagePart2; var entries = WriteWithMock(logLevel, expectedEventLogEntryType, testMessage, entryTypeLayout, EventLogTargetOverflowAction.Split).ToList(); Assert.Equal(expectedEntryCount, entries.Count); }
public void Log(LoggerEntryLevel level, string message, Exception exception = null) { var logEvent = new LogEventInfo(LogLevel.FromOrdinal((int)level), Name, message) { Exception = exception }; foreach (string key in _staticProperties.Keys) { logEvent.Properties[key] = _staticProperties[key]; } _log.Log(logEvent); }
private LogLevel GetNLogLevelFromSeverity(int severity) { LogLevel info = LogLevel.Info; try { info = LogLevel.FromOrdinal(severity); } catch (Exception e) { Ultities.EventLogException("LoggingService.GetNLogLevelFromSeverity", e); } return(info); }
internal static void InitializeLoggers() { lock (LoggerLock) { if (LogManager.Configuration != null) { return; } var config = new LoggingConfiguration(); DateTime now = DateTime.Now; string activeLogFileName = string.Format("{0}\\Logs\\{1}\\[CoolFish-{2}] {3}.txt", Constants.ApplicationPath.Value, now.ToString("MMMM dd yyyy"), Process.GetCurrentProcess().Id, now.ToString("T").Replace(':', '.')); var file = new FileTarget { FileName = activeLogFileName, Layout = @"[${date:format=MM/dd/yy h\:mm\:ss.ffff tt}] [${level:uppercase=true}] ${message} ${onexception:inner=${newline}${exception:format=tostring}}", CreateDirs = true, ConcurrentWrites = false }; config.LoggingRules.Add(new LoggingRule("*", LogLevel.FromOrdinal(UserPreferences.Default.LogLevel), new AsyncTargetWrapper(file) { OverflowAction = AsyncTargetWrapperOverflowAction.Grow })); var remoteTarget = new RemoteTarget { Layout = @"[${level:uppercase=true}] ${message}" }; config.LoggingRules.Add(new LoggingRule("*", LogLevel.Error, new AsyncTargetWrapper(remoteTarget) { OverflowAction = AsyncTargetWrapperOverflowAction.Grow })); LogManager.Configuration = config; } }
private static void AssertLogLevelEnabled(ILoggerBase logger, LogLevel[] expectedLogLevels) { for (int i = LogLevel.MinLevel.Ordinal; i <= LogLevel.MaxLevel.Ordinal; ++i) { var logLevel = LogLevel.FromOrdinal(i); if (expectedLogLevels.Contains(logLevel)) { Assert.True(logger.IsEnabled(logLevel), $"{logLevel} expected as true"); } else { Assert.False(logger.IsEnabled(logLevel), $"{logLevel} expected as false"); } } }
public void Write(LogType type, object properties, string message, params object[] args) { var info = new LogEventInfo(LogLevel.FromOrdinal((int)type), Name, CultureInfo.CurrentCulture, message, args); if (null != properties) { foreach (PropertyDescriptor propertyDescriptor in TypeDescriptor.GetProperties(properties)) { var value = propertyDescriptor.GetValue(properties); info.Properties[propertyDescriptor.Name] = value; } } Log(info); }
/// <summary> /// Converts the <see cref="NLogEvent"/> to <see cref="LogEventInfo"/>. /// </summary> /// <param name="context">The <see cref="NLogEvent"/> object this <see cref="NLogEvent" /> is part of..</param> /// <param name="loggerNamePrefix">The logger name prefix to prepend in front of the logger name.</param> /// <returns>Converted <see cref="LogEventInfo"/>.</returns> internal LogEventInfo ToEventInfo(NLogEvents context, string loggerNamePrefix) { var result = new LogEventInfo(LogLevel.FromOrdinal(this.LevelOrdinal), loggerNamePrefix + context.Strings[this.LoggerOrdinal], context.Strings[this.MessageOrdinal]); result.TimeStamp = new DateTime(context.BaseTimeUtc + this.TimeDelta, DateTimeKind.Utc).ToLocalTime(); for (int i = 0; i < context.LayoutNames.Count; ++i) { string layoutName = context.LayoutNames[i]; string layoutValue = context.Strings[this.ValueIndexes[i]]; result.Properties[layoutName] = layoutValue; } return(result); }
/// <inheritdoc/> public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value) { if (value?.GetType() == typeof(string)) { return(LogLevel.FromString(value.ToString())); } else if (IsNumericType(value?.GetType())) { return(LogLevel.FromOrdinal(Convert.ToInt32(value))); } else { return(base.ConvertFrom(context, culture, value)); } }