static void Main(string[] args)
{
bool asyncLogging = false;
bool useMessageTemplate = false;
int threadCount = 8;
int messageCount = asyncLogging ? 5000000 : 5000000;
int messageSize = 30;
int messageArgCount = 2;
var fileTarget = new NLog.Targets.FileTarget
{
Name = "FileTarget",
FileName = @"C:\Temp\LibLogPerformance\NLog.txt",
KeepFileOpen = true,
ConcurrentWrites = false,
AutoFlush = false,
OpenFileFlushTimeout = 1,
};
var asyncFileTarget = new NLog.Targets.Wrappers.AsyncTargetWrapper(fileTarget)
{
TimeToSleepBetweenBatches = 0,
OverflowAction = NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Block,
BatchSize = 500
};
var benchmarkTool = new BenchmarkTool.BenchMarkExecutor(messageSize, messageArgCount, useMessageTemplate);
if (!asyncLogging)
{
var nlogConfig = new NLog.Config.LoggingConfiguration();
nlogConfig.AddRuleForAllLevels(fileTarget);
NLog.LogManager.Configuration = nlogConfig;
}
else
{
var nlogConfig = new NLog.Config.LoggingConfiguration();
nlogConfig.AddRuleForAllLevels(asyncFileTarget);
NLog.LogManager.Configuration = nlogConfig;
}
LogProvider.SetCurrentLogProvider(new Logging.LogProviders.NLogLogProvider());
var nLogger = LogProvider.GetCurrentClassLogger();
Action <string, object[]> nlogMethod = (messageFormat, messageArgs) =>
{
nLogger.Info(messageFormat, messageArgs);
};
Action nlogFlushMethod = () =>
{
NLog.LogManager.Shutdown();
};
benchmarkTool.ExecuteTest(asyncLogging ? "NLog Async" : "NLog", threadCount, messageCount, nlogMethod, nlogFlushMethod);
if (!asyncLogging)
{
var serilogConfig = new LoggerConfiguration()
.WriteTo.File(@"C:\Temp\LibLogPerformance\Serilog.txt", buffered: true, flushToDiskInterval: TimeSpan.FromMilliseconds(1000));
Log.Logger = serilogConfig.CreateLogger();
}
else
{
var serilogConfig = new LoggerConfiguration()
.WriteTo.Async(a => a.File(@"C:\Temp\LibLogPerformance\SerilogAsync.txt", buffered: true, flushToDiskInterval: TimeSpan.FromMilliseconds(1000)), blockWhenFull: true);
Log.Logger = serilogConfig.CreateLogger();
}
LogProvider.SetCurrentLogProvider(new Logging.LogProviders.SerilogLogProvider());
var seriLogger = LogProvider.GetCurrentClassLogger();
Action <string, object[]> serilogMethod = (messageFormat, messageArgs) =>
{
seriLogger.Info(messageFormat, messageArgs);
};
Action serilogFlushMethod = () =>
{
Log.CloseAndFlush();
};
benchmarkTool.ExecuteTest(asyncLogging ? "Serilog Async" : "Serilog", threadCount, messageCount, serilogMethod, serilogFlushMethod);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
static void Main(string[] args)
{
var usage = "Usage: LoggingPerformance.exe [LoggerName] [MessageCount] [ThreadCount] [MessageSize] [MessageArgCount]";
if ((args.Length > 0))
{
if (string.IsNullOrEmpty(args[0]))
{
Console.WriteLine(usage);
throw new ArgumentException("Invalid first argument! Logger-name as first application argument.");
}
_loggerName = args[0];
}
if ((args.Length > 1) && (!int.TryParse(args[1], out _messageCount)) || (_messageCount < 1))
{
Console.WriteLine(usage);
throw new ArgumentException("Invalid second argument! Message-count as second application argument.");
}
if ((args.Length > 2) && (!int.TryParse(args[2], out _threadCount)) || (_threadCount < 1))
{
Console.WriteLine(usage);
throw new ArgumentException("Invalid third argument! Thread-count as third application argument.");
}
if ((args.Length > 3) && (!int.TryParse(args[3], out _messageSize)) || (_messageSize < 1))
{
Console.WriteLine(usage);
throw new ArgumentException("Invalid fourth argument! Message-size as fourth application argument.");
}
if ((args.Length > 4) && (!int.TryParse(args[5], out _messageArgCount)) || (_messageArgCount > 100))
{
Console.WriteLine(usage);
throw new ArgumentException("Invalid sixth argument! Message-Argument-Count as sixth application argument.");
}
var logger = NLog.LogManager.GetLogger(_loggerName);
if (!logger.IsInfoEnabled)
{
Console.WriteLine(usage);
throw new ArgumentException(string.Format("Logger Name {0} doesn't match any logging rules", _loggerName));
}
Action <string, object[]> logMethod = (messageFormat, messageArgs) =>
{
logger.Info(messageFormat, messageArgs);
};
Action flushMethod = () =>
{
NLog.LogManager.Flush();
};
var benchmarkTool = new BenchmarkTool.BenchMarkExecutor(_messageSize, _messageArgCount, false);
benchmarkTool.ExecuteTest(_loggerName, _threadCount, _messageCount, logMethod, flushMethod);
if (args == null || args.Length == 0)
{
// Wait for user stop action.
Console.WriteLine("Press any key to exit...");
Console.ReadKey();
}
}
static void Main(string[] args)
{
bool asyncLogging = true;
bool useMessageTemplate = false;
int threadCount = 4;
int messageCount = asyncLogging ? 5000000 : 2000000;
int messageSize = 128;
int messageArgCount = 3;
var fileTarget = new NLog.Targets.FileTarget
{
Name = "FileTarget",
FileName = @"C:\Temp\MicrosoftPerformance\NLog.txt",
KeepFileOpen = true,
ConcurrentWrites = false,
AutoFlush = false,
OpenFileFlushTimeout = 1,
};
var asyncFileTarget = new NLog.Targets.Wrappers.AsyncTargetWrapper(fileTarget)
{
TimeToSleepBetweenBatches = 0,
OverflowAction = NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Block,
BatchSize = 500
};
var benchmarkTool = new BenchmarkTool.BenchMarkExecutor(messageSize, messageArgCount, useMessageTemplate);
if (!asyncLogging)
{
var nlogConfig = new NLog.Config.LoggingConfiguration();
nlogConfig.AddRuleForAllLevels(fileTarget);
NLog.LogManager.Configuration = nlogConfig;
}
else
{
var nlogConfig = new NLog.Config.LoggingConfiguration();
nlogConfig.AddRuleForAllLevels(asyncFileTarget);
NLog.LogManager.Configuration = nlogConfig;
}
var nlogProvider = new ServiceCollection().AddLogging(cfg => cfg.AddNLog()).BuildServiceProvider();
var nLogger = nlogProvider.GetService <ILogger <Program> >();
var messageTemplate = benchmarkTool.MessageTemplates[0];
Action <string, object[]> nlogMethod = null;
if (messageArgCount == 0)
{
nlogMethod = LoggerMessageDefineEmpty(nLogger, messageTemplate);
}
else if (messageArgCount == 1)
{
nlogMethod = LoggerMessageDefineOneArg(nLogger, messageTemplate);
}
else if (messageArgCount == 2)
{
nlogMethod = LoggerMessageDefineTwoArg(nLogger, messageTemplate);
}
else if (messageArgCount == 3)
{
nlogMethod = LoggerMessageDefineThreeArg(nLogger, messageTemplate);
}
else
{
nlogMethod = (messageFormat, messageArgs) => { nLogger.LogInformation(messageFormat, messageArgs); };
}
Action nlogFlushMethod = () =>
{
NLog.LogManager.Shutdown();
nlogProvider.Dispose();
};
benchmarkTool.ExecuteTest(asyncLogging ? "NLog Async" : "NLog", threadCount, messageCount, nlogMethod, nlogFlushMethod);
if (!asyncLogging)
{
var serilogConfig = new LoggerConfiguration()
.WriteTo.File(@"C:\Temp\MicrosoftPerformance\Serilog.txt", buffered: true, flushToDiskInterval: TimeSpan.FromMilliseconds(1000));
Log.Logger = serilogConfig.CreateLogger();
}
else
{
var serilogConfig = new LoggerConfiguration()
.WriteTo.Async(a => a.File(@"C:\Temp\MicrosoftPerformance\SerilogAsync.txt", buffered: true, flushToDiskInterval: TimeSpan.FromMilliseconds(1000)), blockWhenFull: true);
Log.Logger = serilogConfig.CreateLogger();
}
var serilogProvider = new ServiceCollection().AddLogging(cfg => cfg.AddSerilog()).BuildServiceProvider();
var serilogLogger = serilogProvider.GetService <ILogger <Program> >();
Action <string, object[]> serilogMethod = null;
if (messageArgCount == 0)
{
serilogMethod = LoggerMessageDefineEmpty(serilogLogger, messageTemplate);
}
else if (messageArgCount == 1)
{
serilogMethod = LoggerMessageDefineOneArg(serilogLogger, messageTemplate);
}
else if (messageArgCount == 2)
{
serilogMethod = LoggerMessageDefineTwoArg(serilogLogger, messageTemplate);
}
else if (messageArgCount == 3)
{
serilogMethod = LoggerMessageDefineThreeArg(serilogLogger, messageTemplate);
}
else
{
serilogMethod = (messageFormat, messageArgs) => { serilogLogger.LogInformation(messageFormat, messageArgs); };
}
Action serilogFlushMethod = () =>
{
Log.CloseAndFlush();
serilogProvider.Dispose();
};
benchmarkTool.ExecuteTest(asyncLogging ? "Serilog Async" : "Serilog", threadCount, messageCount, serilogMethod, serilogFlushMethod);
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
