/// <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));
}
}
