static void Main(string[] args)
{
var config = new NLog.Config.LoggingConfiguration();
using (var fluentdTarget = new NLog.Targets.Fluentd())
{
fluentdTarget.Layout = new NLog.Layouts.SimpleLayout("${longdate}|${level}|${callsite}|${logger}|${message}");
config.AddTarget("fluentd", fluentdTarget);
config.LoggingRules.Add(new NLog.Config.LoggingRule("demo", LogLevel.Debug, fluentdTarget));
var loggerFactory = new LogFactory(config);
var logger = loggerFactory.GetLogger("demo");
logger.Info("Hello World!");
}
}
public void InitializeLogger()
{
var config = new NLog.Config.LoggingConfiguration();
LogManager.Configuration = config;
const string layout =
@"${date:format=yyyy-MM-dd HH\:mm\:ss,fff} ${level:upperCase=True} ${logger} ${message}${newline}${onexception:Process\: ${processname}${newline}Process time\: ${processtime}${newline}Process ID\: ${processid}${newline}Thread ID\: ${threadid}${newline}Details\:${newline}${exception:format=ToString}}";
var boxTarget = new RichTextBoxTarget
{
Layout = layout,
ControlName = "syntaxRichTextBox1",
FormName = "MainDlg",
UseDefaultRowColoringRules = false
};
boxTarget.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Warn", "Orange", "White",
FontStyle.Regular));
boxTarget.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Error", "Red", "White",
FontStyle.Regular));
boxTarget.RowColoringRules.Add(new RichTextBoxRowColoringRule("level == LogLevel.Fatal", "DarkViolet", "White",
FontStyle.Regular));
var traceTarget = new TraceTarget {
Layout = layout
};
config.AddTarget("box", boxTarget);
config.AddTarget("trace", traceTarget);
var r1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Warn, boxTarget);
var r2 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, traceTarget);
config.LoggingRules.Add(r1);
config.LoggingRules.Add(r2);
LogManager.Configuration = config;
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
//Log
var logConfig = new NLog.Config.LoggingConfiguration();
var fileTarget = new NLog.Targets.FileTarget();
fileTarget.FileName = Configuration["Data:Log:logFile"];
fileTarget.Name = "FileLogger";
fileTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger}:${message};${exception}";
logConfig.AddTarget(fileTarget);
logConfig.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget));
if (env.IsDevelopment())
{
var consoleLogger = new NLog.Targets.ColoredConsoleTarget();
consoleLogger.Name = "ConsoleLogger";
consoleLogger.Layout = @"${date:format=HH\:mm\:ss} ${logger}:${message};${exception}";
logConfig.AddTarget(consoleLogger);
logConfig.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleLogger));
}
LogManager.Configuration = logConfig;
// Add the platform handler to the request pipeline.
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
LogManager.GetLogger("Website").Info("Started!");
}
/// <summary>
/// Initializes the configuration of NLog.LogManager with logging to console + file.
/// </summary>
public static void initialize()
{
// create configuration object
var config = new NLog.Config.LoggingConfiguration();
// create targets and add them to the configuration
// --- console
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
// --- file
var fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
// set target properties
consoleTarget.Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} - ${message}";
fileTarget.FileName = getLogFileName();
fileTarget.Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss} [${logger}] ${message}";
// define rules
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(rule1);
var rule2 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule2);
// activate the configuration
NLog.LogManager.Configuration = config;
}
public static ILoggingBuilder ConfigureLoggingServices(ILoggingBuilder loggingBuilder, IConfiguration configuration)
{
var nLogConfiguration = new NLog.Config.LoggingConfiguration();
var consoleTarget = AddConsoleTarget();
var databaseTarget = AddDatabaseTarget(configuration);
nLogConfiguration.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, consoleTarget);
nLogConfiguration.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, databaseTarget);
nLogConfiguration.AddTarget(consoleTarget);
nLogConfiguration.AddTarget(databaseTarget);
var nLogOptions = new NLogAspNetCoreOptions
{
RegisterHttpContextAccessor = true,
IgnoreEmptyEventId = true,
IncludeScopes = true,
ShutdownOnDispose = true
};
var logFactory = NLogBuilder.ConfigureNLog(nLogConfiguration);
logFactory.AutoShutdown = false;
var nLogConfig = logFactory.Configuration;
loggingBuilder.AddNLog(nLogConfig, nLogOptions);
return(loggingBuilder);
}
public static void ConfigureNLog()
{
var config = new NLog.Config.LoggingConfiguration();
var profilerFile = new FileTarget("profilerFile")
{
FileName = $"{AssemblyLocation}/logs/profiler.json",
ArchiveFileName = $"{AssemblyLocation}/logs/profiler.{"{####}"}.json",
Layout = "${message}",
ArchiveNumbering = ArchiveNumberingMode.Rolling,
ArchiveOldFileOnStartup = true,
};
var errorFile = new FileTarget("errorLogFile")
{
FileName = $"{AssemblyLocation}/logs/log.txt",
Layout = $"{"${longdate} ${message} ${exception:format=StackTrace:maxInnerExceptionLevel=5}"}",
};
Debug.WriteLine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location));
config.AddTarget("profiler", profilerFile);
config.AddTarget("error", errorFile);
config.AddRule(LogLevel.Trace, LogLevel.Trace, profilerFile);
config.AddRule(LogLevel.Debug, LogLevel.Fatal, errorFile);
LogManager.Configuration = config;
}
static void PrepareLoggers()
{
// Step 1. Create configuration object
var config = new NLog.Config.LoggingConfiguration();
// Step 2. Create targets and add them to the configuration
var file = new NLog.Targets.FileTarget("FileLogger");
config.AddTarget(file);
// Step 3. Set target properties
file.ArchiveEvery = NLog.Targets.FileArchivePeriod.Day;
file.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence;
file.ArchiveOldFileOnStartup = true;
file.Layout =
@"${date:universalTime=true:format=yyyy-MM-ddTHH\:mm\:ss.fffZ}|${level:uppercase=true}|${logger} ${event-properties:item=logSource}|${message}";
file.LineEnding = NLog.Targets.LineEndingMode.LF;
file.FileName = "mpm.log";
var console = new NLog.Targets.ConsoleTarget("console");
config.AddTarget(console);
console.Layout =
@"[${date:universalTime=false:format=yyyy-MM-ddTHH\:mm\:ss.fffzzz}][${level:uppercase=true}][${logger}]: ${message}";
// Step 4. Define rules
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, file));
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Info, console));
NLog.LogManager.Configuration = config;
}
public static IServiceCollection ConfigureLoggingServices(this IServiceCollection services, IConfiguration configuration)
{
var nLogConfiguration = new NLog.Config.LoggingConfiguration();
var consoleTarget = AddConsoleTarget();
var databaseTarget = AddDatabaseTarget(configuration);
nLogConfiguration.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, consoleTarget);
nLogConfiguration.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, databaseTarget);
nLogConfiguration.AddTarget(consoleTarget);
nLogConfiguration.AddTarget(databaseTarget);
nLogConfiguration.Variables.Add("applicationVersion", ApplicationHelper.ApplicationVersion.GetAssemblyVersion());
nLogConfiguration.Variables.Add("userId", null);
nLogConfiguration.Variables.Add("userSessionId", null);
LogManager.Configuration = nLogConfiguration;
services.AddLogging(builder =>
{
builder.ClearProviders();
builder.AddConfiguration(configuration.GetSection("Logging"));
});
return(services);
}
static Logger()
{
var config = new NLog.Config.LoggingConfiguration();
var fileTarget =
new NLog.Targets.Wrappers.AsyncTargetWrapper(
new NLog.Targets.FileTarget()
{
FileName = (string)ClientSettings.Instance.ClientLogLocation,
ArchiveOldFileOnStartup = true,
KeepFileOpen = true,
MaxArchiveFiles = 10,
EnableFileDelete = true,
CreateDirs = true,
Layout = "${longdate}|${level:uppercase=true}|${logger}|${message}|${exception:innerFormat=ToString:maxInnerExceptionLevel=128:innerExceptionSeparator=String:separator = String:format = ToString}"
},
10000, NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Grow);
config.AddTarget("logfile", fileTarget);
config.LoggingRules.Add(new NLog.Config.LoggingRule("*",
LogLevel.FromString(GlobalSettings.Instance.LogLevel), fileTarget));
LogManager.Configuration = config;
logger = LogManager.GetLogger("Client");
}
public static void Register(HttpConfiguration config)
{
var fileConfig = new AutoConfigField <FileTarget>(
key: "logging.file.settings",
description: "Logger settings for logging to a file",
defaultVal: new FileTarget()
{
Name = "file",
Layout = @"${longdate}|${logger:shortName=true}|${level:uppercase=true}|${message}",
FileName = @"C:\Users\Nolan\Desktop\${shortdate}.txt",
}
);
var fileLevel = new AutoConfigField <string>(
key: "logging.file.level",
description: "What level the file logger should log at",
defaultVal: "Info"
);
// Setup logging
var logConfig = new NLog.Config.LoggingConfiguration();
// File logging
if (!string.Equals("off", fileLevel, StringComparison.InvariantCultureIgnoreCase))
{
logConfig.AddTarget(fileConfig);
logConfig.AddRule(LogLevel.FromString(fileLevel), LogLevel.Off, fileConfig.Value.Name);
}
LogManager.Configuration = logConfig;
}
public void Aggregate_And_AppendProvider()
{
//def console
LoggerFactory.Factory.AddConsole(LogLevel.Trace);
//print 1 line
_logger.Info("------- console -------");
var config = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
var factory = new NLog.LogFactory(config);
//append NLog
LoggerFactory.Factory.AddNLog(factory);
//print 2 line
_logger.Info("------- console & nlog -------");
}
public static IServiceCollection AddCommonLogging(this IServiceCollection services)
{
var properties = new NameValueCollection();
var nlogAdapter = new NLogLoggerFactoryAdapter(properties);
LogManager.Adapter = nlogAdapter;
var config = new NLog.Config.LoggingConfiguration();
config.AddTarget("console", new ConsoleTarget
{
Layout = "${my-layout}"
});
config.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, "console");
NLog.Config.ConfigurationItemFactory.Default.RegisterItemsFromAssembly(Assembly.GetExecutingAssembly());
NLog.LogManager.Configuration = config;
return(services.AddScoped <ILog>(sp =>
{
var context = sp.GetRequiredService <DefaultServiceContext>();
// inject context info to Logger
NLog.MappedDiagnosticsLogicalContext.Set("corp-id", context.CorpId);
NLog.MappedDiagnosticsLogicalContext.Set("user-id", context.UserId);
return LogManager.GetLogger("app");
}));
}
internal static void Configurelogging()
{
//Assigning an adapter to the loggingfacade, this happens to be NLog, we also need to configure the way NLog gets configured, via FILE or code (INLINE).
LogManager.Adapter = new NLogLoggerFactoryAdapter(new System.Collections.Specialized.NameValueCollection() { { "configType", "INLINE" } });
var config = new NLog.Config.LoggingConfiguration();
var dayTarget = new NLog.Targets.FileTarget() { FileName = "logs\\McManage ${shortdate}.log", Encoding = System.Text.Encoding.UTF8, ConcurrentWrites = false };
var tailTarget = new NLog.Targets.FileTarget() { FileName = "McManage.log", Encoding = System.Text.Encoding.UTF8, ConcurrentWrites = false, DeleteOldFileOnStartup = true};
config.AddTarget("dayfile", dayTarget);
config.AddTarget("tailfile", tailTarget);
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, dayTarget));
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, tailTarget));
NLog.LogManager.Configuration = config;
}
/// <inheritdoc />
public virtual void ApplyConfiguration(LoggerOptions options)
{
CurrentOptions = options ?? throw new ArgumentNullException(nameof(options), "Null options are not allowed");
// Validate options
ValidateOptions(CurrentOptions);
// Reconfigure NLog
var fileTarget = new NLog.Targets.FileTarget("FileLog")
{
FileName = options.FileName,
ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence,
ArchiveOldFileOnStartup = options.IsArchiveOnStart,
Layout = options.LogMessageLayout ?? NLOG_LAYOUT,
EnableArchiveFileCompression = options.IsCompressed,
ArchiveAboveSize = options.SizePerFile.SizeInBytes,
MaxArchiveFiles = options.ArchiveCount
};
var configuration = new NLog.Config.LoggingConfiguration();
configuration.AddTarget(fileTarget);
// Configure rule
var filter = string.IsNullOrWhiteSpace(options.Filter) ? "*" : options.Filter;
var fileRule = new NLog.Config.LoggingRule(filter, options.Level.ToNLog(), fileTarget);
configuration.LoggingRules.Add(fileRule);
// Debug
if (options.LogToDebugStream)
{
var debugTarget = new NLog.Targets.DebuggerTarget("DebugLog")
{
Layout = options.LogMessageLayout ?? NLOG_LAYOUT
};
configuration.AddTarget(debugTarget);
var debugRule = new NLog.Config.LoggingRule(filter, options.Level.ToNLog(), debugTarget);
configuration.LoggingRules.Add(debugRule);
}
// Set configuration
NLog.LogManager.Configuration = configuration;
}
internal static void CreateSqliteTarget(bool callFromOutside = true)
{
try
{
NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration();
NLog.Targets.Target dbTarget = FindTargetByName(TARGETDATABASE);
SqliteConnectionStringBuilder connectionStringBuilder = new SqliteConnectionStringBuilder {
ConnectionString = GetConnectionString()
};
string dbFileName = connectionStringBuilder.DataSource;
if (!string.IsNullOrEmpty(dbFileName))
{
FileInfo fileInfo = new FileInfo(dbFileName);
if (!fileInfo.Directory.Exists)
{
fileInfo.Directory.Create();
}
if (!File.Exists(dbFileName))
{
using (FileStream fs = File.Create(dbFileName))
{
fs.Close();
}
config.AddTarget(dbTarget);
using (var context = new NLog.Config.InstallationContext(Console.Out))//Console.Out
{
config.Install(context);
}
}
if (callFromOutside)
{
//register Logs db file
using (FileSystemWatcher fileWatcher = new FileSystemWatcher(fileInfo.Directory.FullName, fileInfo.Name))
{
fileWatcher.NotifyFilter = NotifyFilters.FileName;
fileWatcher.EnableRaisingEvents = true;
fileWatcher.IncludeSubdirectories = false;
fileWatcher.Renamed += (sender, e) =>
{
CreateSqliteTarget(false);
};
fileWatcher.Deleted += (sender, e) =>
{
CreateSqliteTarget(false);
};
}
}
}
}
catch (Exception ex)
{
KraftLogger.LogError(ex);
}
}
private static void ConfigurateFileLogger(string logDir, NLog.Config.LoggingConfiguration logCfg, string loggerName)
{
var fileName = Path.Combine(logDir, loggerName + ".log");
var fileTarget = CreateFileTarget(loggerName, fileName);
logCfg.AddTarget(loggerName, fileTarget);
var rule = new NLog.Config.LoggingRule(loggerName, NLog.LogLevel.Trace, fileTarget);
logCfg.LoggingRules.Add(rule);
}
static CustomLogger()
{
var config = new NLog.Config.LoggingConfiguration();
var consoleLogger = CreateConsoleTarget();
config.AddTarget(consoleLogger);
config.AddRuleForAllLevels(consoleLogger);
LogManager.Configuration = config;
LogManager.Configuration.Variables["mbbsdir"] = Directory.GetCurrentDirectory() + Path.DirectorySeparatorChar;
}
public override void Load()
{
//Create bindings
Rebind<IStartupService>().To<StartupService>().InSingletonScope();
Rebind<IChunk>().To<Chunk>();
Rebind<INetworkPeer>().To<NetworkPeer>().InSingletonScope();
string path = Application.ExecutablePath.Substring(0, Application.ExecutablePath.Length - Path.GetFileName(Application.ExecutablePath).Length);
Rebind<IFileSystem>().To<StandardFileSystem>().InSingletonScope().WithConstructorArgument("workingDirectory", new FileReference(path + "assets/"));
Rebind<NetPeerConfiguration>().ToMethod(context => Kernel.Get<NetworkConfig>().CreateNetPeerConfig()).InSingletonScope();
Rebind<IConfigManager>().To<ConfigManager>().InSingletonScope().WithConstructorArgument("fileReference", new FileReference(Application.ExecutablePath).GetFileName() + "_config.json");
Rebind<ActorProvider>().To<ActorProvider>().InSingletonScope();
Rebind<IActor>().ToProvider<ActorProvider>();
//Logging config stuff
{
NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration();
//targets
NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
NLog.Targets.ConsoleTarget consoleTarget = new NLog.Targets.ConsoleTarget();
config.AddTarget("console", fileTarget);
fileTarget.FileName = "${basedir}/${processname}_Log.txt";
fileTarget.Layout = "[${longdate}] [${level}] [${message}]";
consoleTarget.Layout = ">> [${date:format=HH\\:MM\\:ss}] [${level}] [${message}]";
//rules
NLog.Config.LoggingRule loggingRule;
loggingRule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(loggingRule);
loggingRule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleTarget);
config.LoggingRules.Add(loggingRule);
//activate
NLog.LogManager.Configuration = config;
}
//Register services - Order is important services bound first get to register for events first and consequently receive events first.
IStartupService startup = Kernel.Get<IStartupService>();
startup.RegisterStartupType<IConfigManager>();
startup.RegisterStartupType<IMessageTypeManager>();
startup.RegisterStartupType<IBlockManager>();
startup.RegisterStartupType<IMap>();
}
private static void InitLoggers()
{
var config = new NLog.Config.LoggingConfiguration();
var target = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("logfile", target);
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Info, target));
NLog.LogManager.Configuration = config;
}
public static void ReplaceAllNLogTargetsWithSingleSerilogForwarder()
{
// sic: blindly overwrite the forwarding rules every time
var target = new SerilogTarget();
var cfg = new NLog.Config.LoggingConfiguration();
cfg.AddTarget(nameof(SerilogTarget), target);
cfg.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Trace, target));
// NB assignment must happen last; rules get ingested upon assignment
LogManager.Configuration = cfg;
}
void Init()
{
var config = new NLog.Config.LoggingConfiguration();
Options.TargetGeneratorOptions.ForEach(o =>
{
config.AddTarget(o.Target);
config.AddRule(o.MinLevel, o.MaxLevel, o.Target);
});
NLog.LogManager.Configuration = config;
}
public static void initialize(TestContext testContext)
{
var logConfig = new NLog.Config.LoggingConfiguration();
var layout = NLog.Layouts.Layout.FromString("${longdate}|[${threadid}]|${callsite}|${level:uppercase=true}|${message}${onexception:${newline}${exception:format=tostring}${exception:format=StackTrace}}");
logConfig.AddTarget("console", new NLog.Targets.ColoredConsoleTarget()
{
Layout = layout
});
logConfig.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, "console");
NLog.LogManager.Configuration = logConfig;
}
private static void ConfigureLogger()
{
var codeGeneratorOptions = CodeGeneratorOptions.Instance;
var config = new NLog.Config.LoggingConfiguration();
var minimumLogLevel = codeGeneratorOptions.Verbose ? LogLevel.Trace : LogLevel.Info;
if (codeGeneratorOptions.EnableLoggingToStdout)
{
var consoleTarget = new ConsoleTarget("consoleTarget")
{
Layout = new JsonLayout
{
Attributes =
{
new JsonAttribute("time", "${longdate}"),
new JsonAttribute("level", "${level:uppercase=true}"),
new JsonAttribute("logger", "${logger}"),
new JsonAttribute("message", "${message}"),
new JsonAttribute("exception", "${exception:format=ToString}")
}
}
};
config.AddTarget(consoleTarget);
config.AddRule(minimumLogLevel, LogLevel.Fatal, consoleTarget);
}
var fileTarget = new FileTarget("fileTarget")
{
FileName = codeGeneratorOptions.AbsoluteLogPath,
Layout = "${level:uppercase=true:padding=-5} | ${longdate} | ${logger} | ${message} ${exception:format=ToString}",
DeleteOldFileOnStartup = true
};
config.AddTarget(fileTarget);
config.AddRule(minimumLogLevel, LogLevel.Fatal, fileTarget);
LogManager.Configuration = config;
}
/// <summary>
/// 配置Logger
/// </summary>
static Logger()
{
var config = new NLog.Config.LoggingConfiguration();
string layout = LoggerConfig.Layout;
//控制台
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.Console))
{
AddTarget(new NLog.Targets.ColoredConsoleTarget
{
Name = LoggerConfig.LoggerName,
Layout = layout
});
}
//文件
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.File))
{
AddTarget(new NLog.Targets.FileTarget
{
Name = LoggerConfig.LoggerName,
Layout = layout,
FileName = Path.Combine(Directory.GetCurrentDirectory(), "logs", "${date:format=yyyy-MM-dd}.txt"),
Encoding = Encoding.UTF8
});
}
//数据库
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.RDBMS))
{
AddTarget(new RDBMSTarget
{
Layout = layout
});
}
//ElasticSearch
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.ElasticSearch))
{
AddTarget(new ElasticSearchTarget
{
Layout = layout
});
}
NLog.LogManager.Configuration = config;
void AddTarget(NLog.Targets.Target target)
{
config.AddTarget(target);
config.AddRuleForAllLevels(target);
}
}
private static void ConfigNLog()
{
var config = new NLog.Config.LoggingConfiguration();
var logfile = new NLog.Targets.FileTarget("logfile")
{
FileName = "${basedir}/Log/${date:format=yyyy_MM_dd}.txt",
Layout = "${longdate} ${level} \n ${message} \n ${exception}",
};
config.AddTarget(logfile);
config.AddRule(LogLevel.Trace, LogLevel.Fatal, logfile);
NLog.LogManager.Configuration = config;
}
public Logger(string dir)
{
NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration();
NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = System.IO.Path.Combine(dir, "log.txt");
fileTarget.Layout = "${date:format=MM/dd HH\\:mm\\:ss.ffff}|${level:uppercase=true:padding=6}| ${message}";
fileTarget.DeleteOldFileOnStartup = true;
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
logger = NLog.LogManager.GetLogger("OnlineVideos");
}
public Logger(string dir)
{
NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration();
NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget();
config.AddTarget("file", fileTarget);
fileTarget.FileName = System.IO.Path.Combine(dir, "log.txt");
fileTarget.Layout = "${date:format=MM/dd HH\\:mm\\:ss.ffff}|${level:uppercase=true:padding=6}| ${message}";
fileTarget.DeleteOldFileOnStartup = true;
NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
logger = NLog.LogManager.GetLogger("OnlineVideos");
}
static void NLogConfigure()
{
var config = new NLog.Config.LoggingConfiguration();
var ftarget = new NLog.Targets.FileTarget()
{
FileName = "${basedir}/launcher.txt", Layout = "${longdate}: ${message}"
};
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, ftarget);
config.AddTarget("file", ftarget);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
}
public static void InitSimpleNLogConfigure(NLog.LogLevel minConsoleLogLevel)
{
var logConfig = new NLog.Config.LoggingConfiguration();
//var layout = NLog.Layouts.Layout.FromString("${longdate}|${level:uppercase=true}|${threadid}|${message}${onexception:${newline}${exception:format=tostring}${exception:format=StackTrace}}");
var layout = NLog.Layouts.Layout.FromString("${longdate}|${message}${onexception:${newline}${exception:format=tostring}${exception:format=StackTrace}}");
logConfig.AddTarget("console", new NLog.Targets.ColoredConsoleTarget()
{
Layout = layout
});
logConfig.AddRule(minConsoleLogLevel, NLog.LogLevel.Fatal, "console");
NLog.LogManager.Configuration = logConfig;
}
/// <summary>
/// 配置Logger
/// </summary>
static Logger()
{
var config = new NLog.Config.LoggingConfiguration();
string layout = LoggerConfig.Layout;
//控制台
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.Console))
{
AddTarget(new NLog.Targets.ColoredConsoleTarget
{
Name = LoggerConfig.LoggerName,
Layout = layout
});
}
//文件
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.File))
{
AddTarget(new NLog.Targets.FileTarget
{
Name = LoggerConfig.LoggerName,
Layout = layout,
FileName = $"${{basedir}}/A_logs/{DateTime.Now.ToString("yyyy-MM")}/{DateTime.Now.ToString("yyyy-MM-dd")}.txt"
});
}
//数据库
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.RDBMS))
{
AddTarget(new RDBMSTarget
{
Layout = layout
});
}
//ElasticSearch
if (GlobalSwitch.LoggerType.HasFlag(LoggerType.ElasticSearch))
{
AddTarget(new ElasticSearchTarget
{
Layout = layout
});
}
NLog.LogManager.Configuration = config;
void AddTarget(NLog.Targets.Target target)
{
config.AddTarget(target);
config.AddRuleForAllLevels(target);
}
}
private void SetupLogger()
{
var config = new NLog.Config.LoggingConfiguration();
var logconsole = new NLog.Targets.ConsoleTarget("logconsole")
{
Layout = @"${date:format=HH\:mm\:ss} ${level} ${message} ${exception}"
};
config.AddTarget(logconsole);
config.AddRule(LogLevel.Debug, LogLevel.Fatal, logconsole);
LogManager.Configuration = config;
}
public static NLog.Logger BuildNLog(params Target[] targets)
{
var config = new NLog.Config.LoggingConfiguration();
foreach (var target in targets)
{
config.AddRule(LogLevel.Debug, LogLevel.Fatal, target);
config.AddTarget(target);
}
NLog.LogManager.Configuration = config;
return(config.LogFactory.GetLogger("test", typeof(LoggerBenchmark)));
}
private static NLog.Logger InitNlog()
{
var config = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget("consoleTarget")
{
Layout = @"${longdate} ${level} ${message} ${exception}"
};
config.AddTarget(consoleTarget);
config.AddRule(NLog.LogLevel.FromString(Instance.Nlog.LogLevel), NLog.LogLevel.Fatal, consoleTarget);
NLog.LogManager.Configuration = config;
return(NLog.LogManager.GetCurrentClassLogger());
}
static void Main(string[] args)
{
var config = new NLog.Config.LoggingConfiguration();
using (var fluentdTarget = new NLog.Targets.Fluentd())
{
fluentdTarget.Layout = new NLog.Layouts.SimpleLayout("${longdate}|${level}|${callsite}|${logger}|${message}");
config.AddTarget("fluentd", fluentdTarget);
config.LoggingRules.Add(new NLog.Config.LoggingRule("demo", LogLevel.Debug, fluentdTarget));
var loggerFactory = new LogFactory(config);
var logger = loggerFactory.GetLogger("demo");
logger.Info("Hello World!");
}
}
static CustomLogger()
{
var config = new NLog.Config.LoggingConfiguration();
//Setup Console Logging
var consoleLogger = new ColoredConsoleTarget("consoleLogger")
{
Layout = Layout.FromString("${shortdate} ${time} ${level} ${callsite} ${message}"),
UseDefaultRowHighlightingRules = true
};
consoleLogger.RowHighlightingRules.Add(new ConsoleRowHighlightingRule()
{
Condition = ConditionParser.ParseExpression("level == LogLevel.Debug"),
ForegroundColor = ConsoleOutputColor.Gray
});
consoleLogger.RowHighlightingRules.Add(new ConsoleRowHighlightingRule()
{
Condition = ConditionParser.ParseExpression("level == LogLevel.Info"),
ForegroundColor = ConsoleOutputColor.White
});
consoleLogger.RowHighlightingRules.Add(new ConsoleRowHighlightingRule()
{
Condition = ConditionParser.ParseExpression("level == LogLevel.Warn"),
ForegroundColor = ConsoleOutputColor.DarkYellow
});
consoleLogger.RowHighlightingRules.Add(new ConsoleRowHighlightingRule()
{
Condition = ConditionParser.ParseExpression("level == LogLevel.Error"),
ForegroundColor = ConsoleOutputColor.Red
});
config.AddTarget(consoleLogger);
var fileLogger = new FileTarget("fileLogger")
{
FileName = @"c:\dos\log\log.txt",
Layout = Layout.FromString("${shortdate} ${time} ${level} ${callsite} ${message}"),
DeleteOldFileOnStartup = true
};
//config.AddTarget(fileLogger);
config.AddRuleForAllLevels(consoleLogger);
//config.AddRuleForAllLevels(fileLogger);
LogManager.Configuration = config;
}
/// <summary>
/// Initializes a new instance of the <see cref="CloudWatchService"/> class.
/// </summary>
public CloudWatchService()
{
PerformanceCounters = new ConcurrentDictionary<PerformanceCounterDescription, PerformanceCounter>();
ManagementServiceHost = new WebServiceHost(new ManagementService(this), new Uri(ManagementService.LocalEndpointUrl));
ManagementServiceHost.AddServiceEndpoint(typeof(IManagementService), new WebHttpBinding(), string.Empty);
var config = new NLog.Config.LoggingConfiguration();
config.AddTarget("File", new NLog.Targets.FileTarget()
{
FileName = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "NCloudWatch", "log.txt")
});
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", LogLevel.Info, config.FindTargetByName("File")));
LogManager.Configuration = config;
logger = LogManager.GetLogger("NCloudWatch");
}
public static void MyClassInitialize(TestContext testContext)
{
var config = new NLog.Config.LoggingConfiguration();
var target = new NLog.Targets.DebuggerTarget();
config.AddTarget("debugger", target);
var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, target);
config.LoggingRules.Add(rule);
NLog.LogManager.Configuration = config;
var _logger = NLog.LogManager.GetCurrentClassLogger();
_logger.Debug("Using programmatic config");
}
public void Aggregate_And_AppendProvider() {
//def console
LoggerManager.Factory.AddConsole(LogLevel.Trace);
_logger.Info("------- console -------");
var config = new NLog.Config.LoggingConfiguration();
var consoleTarget = new NLog.Targets.ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
var factory = new NLog.LogFactory(config);
//append NLog
LoggerManager.Factory.AddNLog(factory);
_logger.Info("------- console & nlog -------");
}
public static void MyClassInitialize(TestContext testContext)
{
// set up NLog
var config = new NLog.Config.LoggingConfiguration();
var dt = new NLog.Targets.DebuggerTarget()
{
Layout = "${longdate} ${uppercase:${level}} ${message}",
Name = "t"
};
config.AddTarget("t", dt);
config.LoggingRules.Add(new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, dt));
NLog.LogManager.Configuration = config;
var logger = NLog.LogManager.GetCurrentClassLogger();
logger.Info("Test starting");
// clear existing test objects,
// create new test objects,
// get IDs of test objects
using (var db = new OmbudsmanEntities())
{
TestData = db.TestInitialize().Single();
}
logger.Info("Facility ID {0}, Ombudsman ID {1}", TestData.Facility1, TestData.Ombudsman1);
}
public static void InitializeLog (string logFileName = null, string logLevel = null)
{
// default parameters initialization from config file
if (String.IsNullOrEmpty (logFileName))
{
logFileName = System.Configuration.ConfigurationManager.AppSettings["logFilename"] ?? ("${basedir}/log/default_log_name.log");
}
if (String.IsNullOrEmpty (logLevel))
{
logLevel = System.Configuration.ConfigurationManager.AppSettings["logLevel"] = "Info";
}
// Trying to Parse log Level
LogLevel currentLogLevel;
try
{
currentLogLevel = LogLevel.FromString (logLevel);
}
catch
{
currentLogLevel = LogLevel.Info;
}
// Preparing Log Configuration
var config = new NLog.Config.LoggingConfiguration ();
// Console Output Config
if (!Console.IsOutputRedirected)
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget ();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget ("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule ("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add (rule1);
}
// File Output
var fileTarget = new NLog.Targets.FileTarget ();
fileTarget.FileName = "${basedir}/log/" + logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = 2 * 1024 * 1024; // 2 Mb
fileTarget.MaxArchiveFiles = 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.Date;
fileTarget.ArchiveDateFormat = "yyyyMMdd_HHmmss";
// Setting output file writing to Async Mode
var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
// Adding "File" as one of the log targets
config.AddTarget ("file", wrapper);
// Configuring Log from Config File
fileTarget.FileName = logFileName;
var rule2 = new NLog.Config.LoggingRule ("*", currentLogLevel, fileTarget);
config.LoggingRules.Add (rule2);
// Saving Configurations
LogManager.Configuration = config;
}
protected override void Configure(TestConfiguration config, Random random)
{
base.Configure(config, random);
var c = new NLog.Config.LoggingConfiguration();
var traceTarget = new NLog.Targets.TraceTarget();
traceTarget.Layout = "${message}";
c.AddTarget("trace", traceTarget);
var rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Error, traceTarget);
c.LoggingRules.Add(rule1);
NLog.LogManager.Configuration = c;
Logger = NLog.LogManager.GetCurrentClassLogger();
}
public void TestExecuteExperimentLogs()
{
var target = new MockLogTarget();
var logConfig = new NLog.Config.LoggingConfiguration();
logConfig.AddTarget("MockLogger", target);
NLog.LogManager.Configuration = logConfig;
MockProgress progress = new MockProgress();
Experiment experiment = LoadExperiment("basic_graph.teml");
using (var dispatcher = ExperimentRunnerHelper.CreateExperimentRunner(experiment, AppContext.WorkspaceInstance, AppContext.Components))
{
dispatcher.ExecuteExperiment(progress);
}
// only two nodes log, because the other two are start/end
Assert.AreEqual(2, target.NumEvents);
}
/// <summary>
/// Log initialization.
/// </summary>
internal static void InitializeLog (string logFileName = null, string logLevel = null, InitializationOptions options = null)
{
if (options != null && !options.overrideNLogFileConfiguration && LogManager.Configuration == null)
return;
// default parameters initialization from config file
if (String.IsNullOrEmpty (logFileName))
logFileName = _logFileName ?? System.Configuration.ConfigurationManager.AppSettings["logFilename"];
if (String.IsNullOrEmpty (logFileName))
logFileName = ("${basedir}/log/" + typeof (ConsoleUtils).Namespace.Replace (".SimpleHelpers", "") + ".log");
if (String.IsNullOrEmpty (logLevel))
logLevel = _logLevel ?? (System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info");
// check if log was initialized with same options
if (_logFileName == logFileName && _logLevel == logLevel)
return;
// try to parse loglevel
LogLevel currentLogLevel;
try { currentLogLevel = LogLevel.FromString (logLevel); }
catch { currentLogLevel = LogLevel.Info; }
// save current log configuration
_logFileName = logFileName;
_logLevel = currentLogLevel.ToString ();
// prepare log configuration
var config = new NLog.Config.LoggingConfiguration ();
// console output
if (!Console.IsOutputRedirected)
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget ();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget ("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule ("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add (rule1);
}
// file output
var fileTarget = new NLog.Targets.FileTarget ();
fileTarget.FileName = logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.ConcurrentWriteAttemptDelay = 10;
fileTarget.ConcurrentWriteAttempts = 8;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = 4 * 1024 * 1024; // 4 Mb
fileTarget.MaxArchiveFiles = 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence;
fileTarget.ArchiveDateFormat = "yyyyMMdd_HHmmss";
// set file output to be async (commented out since doesn't work on mono)
// var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
config.AddTarget ("file", fileTarget);
// configure log from configuration file
var rule2 = new NLog.Config.LoggingRule ("*", currentLogLevel, fileTarget);
config.LoggingRules.Add (rule2);
// External Log Target
if (options != null && options.targets != null)
{
foreach (var t in options.targets)
{
config.AddTarget (t);
config.LoggingRules.Add (new NLog.Config.LoggingRule ("*", currentLogLevel, t));
}
}
// set configuration options
LogManager.Configuration = config;
}
/// <summary>
/// Log initialization.
/// </summary>
internal static void InitializeLog (string logFileName = null, string logLevel = null, InitializationOptions initOptions = null, FlexibleOptions appOptions = null)
{
// default parameters initialization from config file
if (String.IsNullOrEmpty (logFileName))
logFileName = _logFileName ?? System.Configuration.ConfigurationManager.AppSettings["logFilename"];
if (String.IsNullOrEmpty (logFileName))
logFileName = ("${basedir}/log/" + typeof (ConsoleUtils).Namespace.Replace (".SimpleHelpers", "") + ".log");
if (String.IsNullOrEmpty (logLevel))
logLevel = _logLevel ?? (System.Configuration.ConfigurationManager.AppSettings["logLevel"] ?? "Info");
// check if log was initialized with same options
if (_logFileName == logFileName && _logLevel == logLevel)
return;
// try to parse loglevel
LogLevel currentLogLevel;
try { currentLogLevel = LogLevel.FromString (logLevel); }
catch { currentLogLevel = LogLevel.Info; }
// save current log configuration
_logFileName = logFileName;
_logLevel = currentLogLevel.ToString ();
// check initialization options
var localOptions = initOptions != null ? initOptions.Clone () : new InitializationOptions ();
// adjust options based on arguments
if (appOptions != null)
{
if (!localOptions.DisableLogFile.HasValue && appOptions.HasOption ("DisableLogFile"))
localOptions.DisableLogFile = appOptions.Get ("DisableLogFile", false);
if (localOptions.EnableLogTargets == null && !String.IsNullOrEmpty (appOptions.Get ("EnableLogTargets")))
localOptions.EnableLogTargets = appOptions.GetAsList ("EnableLogTargets").Where (i => !String.IsNullOrWhiteSpace (i)).Select (i => i.Trim ()).ToArray ();
if (localOptions.DisableLogTargets == null && !String.IsNullOrEmpty (appOptions.Get ("DisableLogTargets")))
localOptions.DisableLogTargets = appOptions.GetAsList ("DisableLogTargets").Where (i => !String.IsNullOrWhiteSpace (i)).Select (i => i.Trim ()).ToArray ();
}
// prepare list of enabled targets
HashSet<string> enabledTargets;
// if enabled log targets was provided, use it!
if (localOptions.EnableLogTargets != null && localOptions.EnableLogTargets.Count > 0)
{
enabledTargets = new HashSet<string> (localOptions.EnableLogTargets, StringComparer.OrdinalIgnoreCase);
}
// else we remove disabled target...
else
{
enabledTargets = new HashSet<string> (StringComparer.OrdinalIgnoreCase) { "console", "file" };
// set enabled targets
if (localOptions.Targets != null)
{
foreach (var i in localOptions.Targets)
{
foreach (var n in GetNLogTargetName (i))
enabledTargets.Add (n);
}
}
// remove disabled targets
if (localOptions.DisableLogTargets != null)
foreach (var i in localOptions.DisableLogTargets)
enabledTargets.Remove (i);
if (localOptions.DisableLogFile ?? false)
enabledTargets.Remove ("file");
}
// prepare log configuration
var config = new NLog.Config.LoggingConfiguration ();
// console output
if (!Console.IsOutputRedirected && enabledTargets.Contains ("console"))
{
var consoleTarget = new NLog.Targets.ColoredConsoleTarget ();
consoleTarget.Layout = "${longdate}\t${callsite}\t${level}\t${message}\t${onexception: \\:[Exception] ${exception:format=tostring}}";
config.AddTarget ("console", consoleTarget);
var rule1 = new NLog.Config.LoggingRule ("*", LogLevel.Trace, consoleTarget);
config.LoggingRules.Add (rule1);
}
// file output
if (enabledTargets.Contains ("file"))
{
var fileTarget = new NLog.Targets.FileTarget ();
fileTarget.FileName = logFileName;
fileTarget.Layout = "${longdate}\t${callsite}\t${level}\t\"${message}${onexception: \t [Exception] ${exception:format=tostring}}\"";
fileTarget.ConcurrentWrites = true;
fileTarget.ConcurrentWriteAttemptDelay = 10;
fileTarget.ConcurrentWriteAttempts = 8;
fileTarget.AutoFlush = true;
fileTarget.KeepFileOpen = true;
fileTarget.DeleteOldFileOnStartup = false;
fileTarget.ArchiveAboveSize = (localOptions.MaxLogFileSize > 0) ? localOptions.MaxLogFileSize : 4 * 1024 * 1024; // 4 Mb
fileTarget.MaxArchiveFiles = (localOptions.MaxArchiveLogFiles > 0) ? localOptions.MaxArchiveLogFiles : 10;
fileTarget.ArchiveNumbering = NLog.Targets.ArchiveNumberingMode.DateAndSequence;
fileTarget.ArchiveDateFormat = "yyyyMMdd";
fileTarget.ArchiveFileName = System.IO.Path.ChangeExtension (logFileName, ".{#}" + System.IO.Path.GetExtension (logFileName));
// set file output to be async (commented out since doesn't work well on mono)
// var wrapper = new NLog.Targets.Wrappers.AsyncTargetWrapper (fileTarget);
config.AddTarget ("file", fileTarget);
// configure log from configuration file
var rule2 = new NLog.Config.LoggingRule ("*", currentLogLevel, fileTarget);
config.LoggingRules.Add (rule2);
}
// External Log Target
if (localOptions.Targets != null)
{
foreach (var t in localOptions.Targets)
{
if (GetNLogTargetName (t).Any (i => enabledTargets.Contains (i)))
{
config.AddTarget (t);
config.LoggingRules.Add (new NLog.Config.LoggingRule ("*", currentLogLevel, t));
}
}
}
// set configuration options
LogManager.Configuration = config;
}
