public Task <int> Execute(GenerateParameters parameters)
{
var mapperConfiguration = new AutoMapperConfiguration();
Mapper.Initialize(mapperConfiguration.Configure);
var generator = new Generator(
new Random(),
parameters.ProductIdMin,
parameters.ProductIdMax,
parameters.CustomerIdMin,
parameters.CustomerIdMax,
parameters.RevenueMin,
parameters.RevenueMax);
var config = new LoggingConfiguration();
var now = DateTime.Now;
var logfile = new FileTarget {
FileName = $"generated-{now:yyyyMMddHHmmss}.log"
};
var logconsole = new ConsoleTarget();
config.AddRule(LogLevel.Info, LogLevel.Fatal, logconsole);
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);
LogManager.Configuration = config;
var logger = LogManager.GetCurrentClassLogger();
var cancellationTokenSource = new CancellationTokenSource();
Task.WaitAll(ToggleSignalStateTaskAsync(parameters, cancellationTokenSource), GeneratorTask(parameters, generator, logger, cancellationTokenSource));
return(Task.FromResult(0));
}
public static void AssemblyInit(TestContext context)
{
var config = new LoggingConfiguration();
var debuggerTarget = new DebuggerTarget("debugger")
{
Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}"
};
config.AddTarget(debuggerTarget);
config.AddRuleForAllLevels(debuggerTarget);
var consoleTarget = new ConsoleTarget("console")
{
Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}"
};
config.AddTarget(consoleTarget);
config.AddRuleForAllLevels(consoleTarget);
config.AddRule(LogLevel.Fatal, LogLevel.Trace, consoleTarget);
LogManager.Configuration = config;
IndyDotNet.Utils.Logger.Init();
LogManager.GetCurrentClassLogger().Info("Logging started");
}
private static void LoggerInit()
{
// Step 1. Create configuration object
var config = new LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var consoleTarget = new ConsoleTarget();
config.AddTarget("console", consoleTarget);
var fileTarget = new FileTarget();
config.AddTarget("file", fileTarget);
const string Layout =
@"[${date:format=HH\:mm\:ss}] [${level}] ${message} "
+ "${onexception:${exception:format=tostring,stacktrace}${newline}${stacktrace}}";
// Step 3. Set target properties
consoleTarget.Layout = Layout;
fileTarget.FileName = "Cruciatus.log";
fileTarget.Layout = Layout;
// Step 4. Define rules
var rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(rule1);
var rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule2);
// Step 5. Activate the configuration
LogManager.Configuration = config;
}
private static LoggingConfiguration ConfigureLogger()
{
var config = new LoggingConfiguration();
var fileTarget = new FileTarget
{
Name = "logFile",
FileName = @"\\Storage1\Users\garmstrong\RenameLogs\SimpleLog.txt",
Layout = "[${level}] ${message}",
KeepFileOpen = true,
//DeleteOldFileOnStartup = true,
};
var consoleTarget = new ConsoleTarget {
Name = "logConsole"
};
var fileRule = new LoggingRule("logFile", LogLevel.Debug, fileTarget);
var consoleRule = new LoggingRule("logConsole", LogLevel.Debug, consoleTarget);
config.AddTarget(fileTarget);
config.AddTarget(consoleTarget);
config.LoggingRules.Add(fileRule);
config.LoggingRules.Add(consoleRule);
return(config);
}
/// <summary>
/// Inits logging facility and loggers.
/// </summary>
private static void InitLoggers()
{
LogManager.Enabled = true; // enable logger by default.
foreach (var targetConfig in LogConfig.Instance.Targets)
{
if (!targetConfig.Enabled)
{
continue;
}
LogTarget target = null;
switch (targetConfig.Target.ToLower())
{
case "console":
target = new ConsoleTarget(targetConfig.MinimumLevel, targetConfig.MaximumLevel,
targetConfig.IncludeTimeStamps);
break;
case "file":
target = new FileTarget(targetConfig.FileName, targetConfig.MinimumLevel,
targetConfig.MaximumLevel, targetConfig.IncludeTimeStamps,
targetConfig.ResetOnStartup);
break;
}
if (target != null)
{
LogManager.AttachLogTarget(target);
}
}
}
/// <summary>
/// This code sets up the different
/// logging levels for the mod.
/// </summary>
private void SetupLogging()
{
var config = new LoggingConfiguration();
// The layout of the log
var layout = "[${time}] [" + Assembly.GetAssembly(typeof(CSM)).GetName().Version.ToString() + "] [${level}] ${message} ${exception:format=tostring}";
// Target for file logging
var logfile = new FileTarget("logfile")
{
FileName = "multiplayer-logs/log-current.txt",
ArchiveFileName = "multiplayer-logs/log-${shortdate}.txt",
Layout = layout,
ArchiveEvery = FileArchivePeriod.Day,
MaxArchiveFiles = 7,
ConcurrentWrites = true,
};
// Target for console logging
var logconsole = new ConsoleTarget("logconsole")
{
Layout = layout
};
// While in development set both levels to start at debug, later on we
// want to set an option to do this.
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);
LogManager.Configuration = config;
}
public Bebop()
{
LoggingConfiguration config = new LoggingConfiguration();
FileTarget logfile = new FileTarget("logfile")
{
FileName = "BebopFileLog.txt"
};
ConsoleTarget consoleLog = new ConsoleTarget("logconsole");
config.AddRule(LogLevel.Info, LogLevel.Fatal, consoleLog);
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logfile);
LogManager.Configuration = config;
Logger = LogManager.GetCurrentClassLogger();
// Set Bebop sensors
Sensors = new List <Sensor.Sensor>
{
Battery,
FlyingState,
Altitude,
FlatTrimChanged,
AttitudeChanged
};
}
static AppLog()
{
var fileTarget = new FileTarget("file_log")
{
Encoding = Encoding.UTF8,
LineEnding = LineEndingMode.CRLF,
Layout = "${longdate} ${level} ${message} ${exception}",
FileName = "${basedir}/Logs/event.log",
MaxArchiveFiles = 7,
ArchiveEvery = FileArchivePeriod.Day,
ArchiveNumbering = ArchiveNumberingMode.Date
};
var config = new LoggingConfiguration();
config.AddTarget(fileTarget);
config.AddRuleForAllLevels(fileTarget);
var consoleTarget = new ConsoleTarget("console_log")
{
Layout = "${longdate} ${level} ${message} ${exception}",
AutoFlush = true,
Encoding = Encoding.UTF8
};
config.AddTarget(consoleTarget);
config.AddRuleForAllLevels(consoleTarget);
LogManager.Configuration = config;
Logger = LogManager.GetLogger("DesktopDemo");
}
/// <summary>
/// Instantiate a Logger with the specified name and minimum message level
/// </summary>
/// <param name="name">Name of logger</param>
/// <param name="minLevel">Messages of lower level than this will not be logged</param>
/// <returns>Logger with appropriate name, minimum level and settings</returns>
private Logger GetLogger(string name, NLog.LogLevel minLevel)
{
string savePath = GetSavePath(); //Generate save path
var fileTarget = new FileTarget(); // Create a target
var consoleTarget = new ConsoleTarget();
if (String.IsNullOrWhiteSpace(name))
{
name = "Log";
}
_logConfig.AddTarget($"{name}_file", fileTarget); // Add the target to the configuration
_logConfig.AddTarget($"{name}_console", consoleTarget);
string time = _logStart.ToString("yyyyMMdd-HHmm");
fileTarget.FileName = $@"{savePath}\{time}_{name}.log"; //set name (and path) of savefile
fileTarget.Layout = @"${date} | ${level} | ${message}"; //Define layout for file
consoleTarget.Layout = @"${time} | ${level} | ${message}";
var fileRule = new LoggingRule(name, minLevel, fileTarget); //Create logging rules...
var consoleRule = new LoggingRule(name, minLevel, consoleTarget);
_logConfig.LoggingRules.Add(fileRule); //...and add to configuration
_logConfig.LoggingRules.Add(consoleRule);
LogManager.Configuration = _logConfig; //Activate the configuration
return(LogManager.GetLogger(name));
}
private static void ConfigureStructuredLogging()
{
try
{
var config = new LoggingConfiguration();
var consoleTarget = new ConsoleTarget
{
Layout = new JsonLayout
{
IncludeAllProperties = true,
Attributes =
{
new JsonAttribute("time", new SimpleLayout("${longdate}")),
new JsonAttribute("level", new SimpleLayout("${level}")),
new JsonAttribute("message", new SimpleLayout("${message}")),
}
}
};
config.AddRuleForAllLevels(consoleTarget, "*");
LogManager.Configuration = config;
}
catch (Exception e)
{
Console.WriteLine("An error occurred while attempting to configure the logger. Exiting.");
Console.WriteLine(e.StackTrace);
throw;
}
}
/// <summary>
/// Configure logger
/// </summary>
private static void ConfigureLogger()
{
var config = new LoggingConfiguration();
// Define layout
const string?layout = "${longdate} [Thread-${threadid}] [${level}] ${logger} - ${message}";
// Define target
var console = new ConsoleTarget {
Layout = layout
};
var file = new FileTarget {
Layout = layout,
FileName = "${basedir}/Logs/application.log",
ArchiveFileName = "${basedir}/Logs/application_{#}.log",
ArchiveNumbering = ArchiveNumberingMode.Date,
ArchiveAboveSize = 1 * 1000 * 1000, // 1Mo
MaxArchiveFiles = 3,
};
// Add rules
#if DEBUG
config.AddRule(LogLevel.Trace, LogLevel.Fatal, console);
config.AddRule(LogLevel.Trace, LogLevel.Fatal, file);
#else
config.AddRule(LogLevel.Info, LogLevel.Fatal, console);
config.AddRule(LogLevel.Info, LogLevel.Fatal, file);
#endif
// Apply
LogManager.Configuration = config;
}
static void СконфигурироватьЛогирование()
{
var названиеПродукта = Assembly.GetEntryAssembly().GetCustomAttributes(false)
.OfType <AssemblyProductAttribute>()
.FirstOrDefault()
?.Product;
var конфигурация = new LoggingConfiguration();
var файловыйЛог = new FileTarget("логфайл")
{
FileName = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData),
названиеПродукта,
"Logs",
"log.txt")
};
var консольныйЛог = new ConsoleTarget("консольный лог");
Directory.CreateDirectory(Path.GetDirectoryName(файловыйЛог.FileName.ToString().Trim('\'')));
конфигурация.AddTarget(файловыйЛог);
конфигурация.AddTarget(консольныйЛог);
конфигурация.AddRuleForAllLevels(файловыйЛог);
конфигурация.AddRuleForAllLevels(консольныйЛог);
LogManager.Configuration = конфигурация;
}
/// <summary>
/// Configures the logger according to <paramref name="args"/>.
/// </summary>
/// <param name="args"><see cref="ProgramArguments"/></param>
private void ConfigLogger(ProgramArguments args)
{
LogLevel consoleLogLevel = args.Verbose ? LogLevel.Info : LogLevel.Off;
var config = new LoggingConfiguration();
// Configure the targets and rules.
var consoleTarget = new ConsoleTarget
{
Layout = "${uppercase:${level}}: ${message} ${exception}"
};
config.AddRule(consoleLogLevel, LogLevel.Error, consoleTarget);
Directory.CreateDirectory("logs");
var fileTarget = new FileTarget
{
FileName = Path.Combine("logs", $"{_programData.GameAbbreviation}_Version_Swapper.{DateTime.Now:s}.log"),
Layout = "${longdate} | ${stacktrace} | ${uppercase:${level}} | ${message} ${exception}"
};
config.AddRule(LogLevel.Debug, LogLevel.Fatal, fileTarget);
// Set and load the configuration.
LogManager.Configuration = config;
LogManager.ReconfigExistingLoggers();
_programData.NLogger.Info("Verbose mode activated.");
}
public static void Main(string[] args)
{
var loggerConfig = new LoggingConfiguration();
var newReliTarget = new ConsoleTarget
{
Name = "NewRelicTarget",
Layout = new NewRelicJsonLayout()
};
loggerConfig.AddTarget(newReliTarget);
loggerConfig.AddRuleForAllLevels("NewRelicTarget");
LogManager.Configuration = loggerConfig;
var logger = LogManager.GetCurrentClassLogger();
try
{
logger.Debug("init main");
var host = CreateHostBuilder(args).Build();
host.Run();
}
catch (Exception ex)
{
logger.Error(ex, "Stopped program because of exception");
throw;
}
finally
{
NLog.LogManager.Shutdown();
}
CreateHostBuilder(args).Build().Run();
}
/// <summary>
/// Creates new or updates an existing configuration with the console target name "ConsoleTarget".
/// It will be like the [target xsi:type="Console" name="ConsoleTarget" layout="${date:universalTime=true:format=HH\:mm\:ss}|${level:uppercase=true}|${message}" ]
/// The rule will be set to like [logger name="*" minlevel="Info" writeTo="ConsoleTarget"]
/// </summary>
/// <param name="nLogSettings">The settings for <see cref="NLogLogger"/>.</param>
/// <param name="configuration">The NLog logging configuration.</param>
/// <returns></returns>
public static LoggingConfiguration GenerateUpdateConsoleLoggingConfiguration(NLogLoggerSettings nLogSettings, LoggingConfiguration configuration = null)
{
LoggingConfiguration nlogConfiguration = configuration ?? new LoggingConfiguration();
var consoleTarget = new ConsoleTarget();
consoleTarget.Name = nameof(ConsoleTarget);
consoleTarget.Layout = @"${date:universalTime=true:format=HH\:mm\:ss}|${level:uppercase=true}|${message}";
nlogConfiguration.RemoveTarget(consoleTarget.Name);
nlogConfiguration.AddTarget(consoleTarget.Name, consoleTarget);
if (nLogSettings.AcceptedCategoryNames.Count == 0)
{
var rule = new LoggingRule("*", WrappedNLog.LogLevel.Info, WrappedNLog.LogLevel.Fatal, consoleTarget);
nlogConfiguration.LoggingRules.Add(rule);
}
else
{
// Create rules for all categories in the settings.
foreach (var loggerNamePattern in nLogSettings.AcceptedCategoryNames)
{
var rule = new LoggingRule(loggerNamePattern, WrappedNLog.LogLevel.Info, WrappedNLog.LogLevel.Fatal, consoleTarget);
nlogConfiguration.LoggingRules.Add(rule);
}
}
return(nlogConfiguration);
}
private static ILogger GetLogger()
{
var logConfig = new LoggingConfiguration();
var fileTarget = new FileTarget()
{
Name = "fileLog",
FileName = "${basedir}/Logs/info.log",
CreateDirs = true,
Layout = "${longdate} Thr: ${threadid} - [${level}] - ${message} ${exception}",
ArchiveFileName = $"./Logs/Archives/{DateTime.Now.Day}-{DateTime.Now.Month}-{DateTime.Now.Year}.log",
ArchiveOldFileOnStartup = true
};
var consoleTarget = new ConsoleTarget("consoleLog")
{
Layout = @"${date:format=HH\:mm\:ss} [${threadid}] [${level}] - ${message} ${exception}",
OptimizeBufferReuse = true
};
logConfig.AddTarget(fileTarget);
logConfig.AddTarget(consoleTarget);
logConfig.AddRuleForAllLevels(fileTarget);
logConfig.AddRuleForAllLevels(consoleTarget);
LogManager.Configuration = logConfig;
return(LogManager.GetCurrentClassLogger());
}
/// <summary>
/// Initializes the logger.
/// </summary>
/// <returns></returns>
private static ILogger InitLogger()
{
// Step 1. Create configuration object
var config = new LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var consoleTarget = new ConsoleTarget();
config.AddTarget("console", consoleTarget);
// Step 3. Set target properties
consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}";
// Step 4. Define rules
#if DEBUG
var rule1 = new LoggingRule("*", LogLevel.Debug, consoleTarget);
#elif UNIT_TEST
var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget);
#else
var rule1 = new LoggingRule("*", LogLevel.Warn, consoleTarget);
#endif
config.LoggingRules.Add(rule1);
// Step 5. Activate the configuration
LogManager.Configuration = config;
// Example usage
return(LogManager.GetLogger("VkApi"));
}
public static void Setup()
{
if (LogManager.Configuration == null)
{
LogManager.Configuration = new LoggingConfiguration();
}
else if (LogManager.Configuration.FindTargetByName <ConsoleTarget>(TestLoggerName) != null)
{
return;
}
var consoleTarget = new ConsoleTarget(TestLoggerName)
{
Layout = @"${longdate}|${level}|${logger}|${message}|${exception:format=toString,Data:maxInnerExceptionLevel=5}",
AutoFlush = true
};
LoggingConfiguration config = LogManager.Configuration;
config.AddTarget(consoleTarget);
config.AddRuleForAllLevels(consoleTarget);
LogManager.GlobalThreshold = LogLevel.Trace;
LogManager.GetCurrentClassLogger().Info("TestLogger added to LogManager config");
}
private static void ConfigureNLog()
{
var config = new LoggingConfiguration();
var fileTarget =
new FileTarget
{
FileName = Path.GetFullPath("CoinbaseSample.log")
};
config.AddTarget("logfile", fileTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
var consoleTarget =
new ConsoleTarget
{
Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} ${message}"
};
config.AddTarget("console", consoleTarget);
config.LoggingRules.Add(new LoggingRule("*", LogLevel.Info, consoleTarget));
LogManager.Configuration = config;
LogManager.GetCurrentClassLogger().Info("Log initialized");
Api.SetLogger(new GdaxApiLogger());
}
private static LogFactory GetLogFactory(string[] args, string defaultPath)
{
string logPath = LogBaseProperties.GetLogPath(args, defaultPath);
var logConfig = new LoggingConfiguration();
var target = new FileTarget()
{
Name = "Def",
FileName = logPath,
Layout = "${date} ${message} ${onexception:inner=${exception:format=toString}}"
};
logConfig.AddTarget(target);
logConfig.AddRuleForAllLevels(target);
var consoleTarget = new ConsoleTarget
{
Layout = "${date} ${message} ${onexception:inner=${exception:format=toString}}",
Name = "console"
};
logConfig.AddTarget(consoleTarget);
logConfig.AddRuleForAllLevels(consoleTarget);
var logFactory = new LogFactory(logConfig);
return(logFactory);
}
public void ResolvingTest()
{
var test = _container.Resolve <TestClass>();
Assert.IsNotNull(test);
// Step 1.Create configuration object
var config = new LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var target = new ConsoleTarget();
config.AddTarget("console", target);
// Step 3. Set target properties
// Step 4. Define rules
LoggingRule rule1 = new LoggingRule("*", LogLevel.Trace, target);
config.LoggingRules.Add(rule1);
//config.LoggingRules.Remove(rule);
// Step 5. Activate the configuration
LogManager.Configuration = config;
test.Trace();
}
public static void Main(string[] args)
{
MainConfig app = JsonFileParser.DeserializeFile <MainConfig> ("Config/MainConfig.json");
var cfg = new LoggingConfiguration();
var console = new ConsoleTarget();
console.Layout = @"${level} [${logger}] - ${message}";
cfg.AddTarget("console", console);
LogLevel level = DetermineLogLevel(app.LogLevel);
cfg.LoggingRules.Add(new LoggingRule("*", level, console));
LogManager.Configuration = cfg;
Logger logger = LogManager.GetCurrentClassLogger();
var uri = String.Format("http://localhost:{0}", app.Port);
var host = new NancyHost(new Uri(uri));
logger.Info("Listening on {0}", uri);
host.Start();
logger.Info("Connecting to zookeeper and registering service...");
ZookeeperAccessor accessor = new ZookeeperAccessor(app.ZookeeperHost, app.ZookeeperPort);
accessor.RegisterService("1.0", "location", app.Port, "/location");
accessor.RegisterService("1.0", "time", app.Port, "/time");
logger.Info("Service registration complete");
while (true)
{
}
}
static void Main(string[] args)
{
LogManager.Configuration = new LoggingConfiguration();
var target = new ConsoleTarget("PinMameSilk");
LogManager.Configuration.AddTarget(target);
LogManager.Configuration.AddRule(LogLevel.Info, LogLevel.Fatal, target);
LogManager.ReconfigExistingLoggers();
var options = WindowOptions.Default;
options.Size = new Vector2D <int>(128 * 6, 32 * 6);
options.Title = "PinMAME Silk";
var window = Window.Create(options);
DmdController dmdController = null;
UIOverlayController uiOverlayController = null;
PinMameController pinMameController = null;
GL gl = null;
window.Load += () =>
{
gl = GL.GetApi(window);
var input = window.CreateInput();
dmdController = DmdController.Instance(window);
uiOverlayController = UIOverlayController.Instance(window, input, gl);
pinMameController = PinMameController.Instance();
// (ImGui needs resize message first)
window.Resize += (size) =>
{
size.Y = size.X * 32 / 128;
window.Size = size;
};
};
window.FramebufferResize += (size) =>
{
gl.Viewport(size);
};
window.Render += (delta) =>
{
gl.Clear((uint)ClearBufferMask.ColorBufferBit);
gl.ClearColor(1.0f, 1.0f, 0.0f, 1.0f);
dmdController.Render();
uiOverlayController.Render(delta);
};
window.Run();
}
private static void SetupLogger()
{
var config = new LoggingConfiguration();
var logconsole = new ConsoleTarget("logconsole");
if (!Directory.Exists("logs"))
{
Directory.CreateDirectory("logs");
}
var logfile = new FileTarget("logfile")
{
FileName = Directory.GetCurrentDirectory() + "\\logs\\bmlauncher_report__" + CurrentTime + ".log"
};
var logDirectory = new DirectoryInfo(Directory.GetCurrentDirectory() + "\\logs");
var oldestAllowedArchive = DateTime.Now - new TimeSpan(3, 0, 0, 0);
foreach (FileInfo file in logDirectory.GetFiles())
{
if (file.CreationTime < oldestAllowedArchive)
{
file.Delete();
}
}
config.AddRule(LogLevel.Debug, LogLevel.Warn, logconsole);
config.AddRule(LogLevel.Debug, LogLevel.Warn, logfile);
LogManager.Configuration = config;
}
public NLogManager()
{
var config = new LoggingConfiguration();
var consoleTarget = new ConsoleTarget();
config.AddTarget("console", consoleTarget);
var consoleRule = new LoggingRule("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(consoleRule);
var fileTarget = new FileTarget();
string folder = Android.OS.Environment.ExternalStorageDirectory.Path;
var date = DateTime.UtcNow.Date.ToString("dd.MM.yyyy");
fileTarget.FileName = Path.Combine(folder, "BudgetUnderControl", string.Format("buc-Log-{0}.txt", date));
config.AddTarget("file", fileTarget);
var fileRule = new LoggingRule("*", LogLevel.Info, fileTarget);
config.LoggingRules.Add(fileRule);
LogManager.Configuration = config;
}
static async Task Start()
{
Console.Title = "Samples.SampleWithClean";
#region ConfigureNLog
ConfigurationItemFactory.Default.LayoutRenderers
.RegisterDefinition("customexception", typeof(CustomExceptionLayoutRenderer));
var config = new LoggingConfiguration();
var layout = "$|${logger}|${message}${onexception:${newline}${customexception:format=tostring}}";
var consoleTarget = new ConsoleTarget
{
Layout = layout
};
config.AddTarget("console", consoleTarget);
var consoleRule = new LoggingRule("*", LogLevel.Info, consoleTarget);
config.LoggingRules.Add(consoleRule);
var fileTarget = new FileTarget
{
FileName = "log.txt",
Layout = layout
};
config.AddTarget("file", fileTarget);
var fileRule = new LoggingRule("*", LogLevel.Info, fileTarget);
config.LoggingRules.Add(fileRule);
LogManager.Configuration = config;
NServiceBus.Logging.LogManager.Use <NLogFactory>();
var endpointConfiguration = new EndpointConfiguration("Samples.SampleWithClean");
#endregion
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.UsePersistence <InMemoryPersistence>();
endpointConfiguration.EnableInstallers();
DisableRetries(endpointConfiguration);
#region customization-config
var recoverability = endpointConfiguration.Recoverability();
recoverability.Failed(failed => failed.HeaderCustomization(StackTraceCleaner.CleanUp));
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
try
{
await Run(endpointInstance)
.ConfigureAwait(false);
}
finally
{
await endpointInstance.Stop()
.ConfigureAwait(false);
}
}
private static void Main(string[] args)
{
// Configure NLog.
var nlogConfig = new LoggingConfiguration();
var fileTarget = new FileTarget("file")
{
FileName = "nlog.log",
KeepFileOpen = true,
ConcurrentWrites = false
};
nlogConfig.AddTarget(fileTarget);
nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, fileTarget));
var consoleTarget = new ConsoleTarget("console");
nlogConfig.AddTarget(consoleTarget);
nlogConfig.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, consoleTarget));
// Configure PostSharp Logging to use NLog.
LoggingServices.DefaultBackend = new NLogLoggingBackend(new LogFactory(nlogConfig));
LogManager.EnableLogging();
// Simulate some business logic.
QueueProcessor.ProcessQueue(@".\Private$\SyncRequestQueue");
}
public static void SetupLog()
{
var configuration = new LoggingConfiguration();
var console = new ConsoleTarget
{
Layout = @"${date}|${level:uppercase=true}|${message} ${exception}|${logger}|${all-event-properties}"
};
var file = new FileTarget
{
FileName = Path.Combine(Directory.GetCurrentDirectory(), "logs", "log.log"),
Layout = @"${date}|${level:uppercase=true}|${message} ${exception}|${logger}|${all-event-properties}",
ArchiveEvery = FileArchivePeriod.Day,
ArchiveFileName = Path.Combine(Directory.GetCurrentDirectory(), "logs", DateTime.Now.ToString("yyyyMMdd") + ".log")
};
configuration.AddTarget("Console", console);
configuration.AddTarget("File", file);
configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, console));
configuration.LoggingRules.Add(new LoggingRule("*", LogLevel.Debug, file));
LogManager.Configuration = configuration;
}
/// <summary>
/// Configure NLog.
/// </summary>
/// <remarks>
/// Level < 0 --> Clear Config
/// Level = 0 --> Do nothing
/// Level = 1 --> Debug
/// Leven > 1 --> Trace
/// </remarks>
/// <param name="level"></param>
public static void ConfigureLogging(int level)
{
if (level < 0)
{
// Need to reset configuration to null for NLog 2.0 on mono
// so we don't hang on exit.
LogManager.Configuration = null;
return;
}
if (level == 0)
{
return;
}
if (LogManager.Configuration != null && LogManager.Configuration.LoggingRules.Count > 0)
{
Console.WriteLine("Logging was configured by a .config file, not changing the configuration.");
return;
}
var nconfig = new LoggingConfiguration();
var consoleTarget = new ConsoleTarget();
nconfig.AddTarget("console", consoleTarget);
consoleTarget.Layout = "${logger} ${message}";
var rule = new LoggingRule("*", level == 1 ? LogLevel.Debug : LogLevel.Trace, consoleTarget);
nconfig.LoggingRules.Add(rule);
LogManager.Configuration = nconfig;
}
public void AddConsoleOutput()
{
DebugFileWriter(
LogDirectory, String.Format(
"AddConsoleOutput called."
));
RemoveTarget("ConsoleTargetWrapper");
var wrapper = new AsyncTargetWrapper();
wrapper.Name = "ConsoleTargetWrapper";
var target = new ConsoleTarget()
{
Layout = "${level}, ${logger}, ${message}",
Error = false
};
target.Name = "ConsoleTarget";
wrapper.WrappedTarget = target;
AddLogTarget(wrapper, LogSeverity);
}
protected virtual void SetupLogging()
{
var config = new LoggingConfiguration();
var consoleTarget = new ConsoleTarget();
consoleTarget.Layout = @"${message}";
config.AddTarget("console", consoleTarget);
var rule = new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
LogManager.Adapter = new NLogLoggerFactoryAdapter(new NameValueCollection());
}
