private static void InitLogging() { var s_Config = new LoggingConfiguration(); var s_ConsoleTarget = new ColoredConsoleTarget(); s_Config.AddTarget("console", s_ConsoleTarget); s_ConsoleTarget.Layout = @"[${date:format=HH\:mm\:ss.fff}] ${logger} >> ${message}"; var s_ConsoleRule = new LoggingRule("*", LogLevel.Trace, s_ConsoleTarget); s_Config.LoggingRules.Add(s_ConsoleRule); var s_FileTarget = new FileTarget(); s_Config.AddTarget("file", s_FileTarget); s_FileTarget.FileName = "${basedir}/GrooveCaster.log"; s_FileTarget.Layout = @"[${date:format=HH\:mm\:ss.fff}] ${logger} >> ${message}"; s_FileTarget.ArchiveFileName = "${basedir}/GrooveCaster.{#}.log"; s_FileTarget.ArchiveEvery = FileArchivePeriod.Day; s_FileTarget.ArchiveNumbering = ArchiveNumberingMode.Date; s_FileTarget.ArchiveDateFormat = "yyyMMdd"; var s_FileRule = new LoggingRule("*", LogLevel.Trace, s_FileTarget); s_Config.LoggingRules.Add(s_FileRule); LogManager.Configuration = s_Config; }
public static void InitializeLogging() { var config = new LoggingConfiguration(); Target debuggerTarget = new DebuggerTarget() { Layout = "${longdate}|${level}|${logger}|${message} ${exception:format=tostring}" }; Target consoleTarget = new ColoredConsoleTarget() { Layout = "${longdate}|${level}|${logger}|${message} ${exception:format=tostring}" }; #if !DEBUG debuggerTarget = new AsyncTargetWrapper(debuggerTarget); consoleTarget = new AsyncTargetWrapper(consoleTarget); #else new AsyncTargetWrapper().Wrap(); // Placeholder for optimizing imports #endif config.AddTarget("debugger", debuggerTarget); config.AddTarget("console", consoleTarget); var debuggerRule = new LoggingRule("*", LogLevel.Trace, debuggerTarget); config.LoggingRules.Add(debuggerRule); var consoleRule = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(consoleRule); LogManager.Configuration = config; }
public static void BuildLogger() { var consoleTarget = new ColoredConsoleTarget { Layout = "${message} ${exception:format=tostring}" }; var debuggerTarget = new DebuggerTarget() { Layout = "${message} ${exception:format=tostring}" }; var consoleRule = new LoggingRule("*", LogLevel.Debug, consoleTarget); var debuggerRule = new LoggingRule("*", LogLevel.Debug, debuggerTarget); var config = new LoggingConfiguration(); config.LoggingRules.Add(consoleRule); config.LoggingRules.Add(debuggerRule); config.AddTarget("debugger", debuggerTarget); config.AddTarget("console", consoleTarget); LogManager.Configuration = config; }
private static Logger CreateLogger() { var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); fileTarget.FileName = "${basedir}\\AsteriskLog.txt"; fileTarget.Layout = "${date:format=yyyy-MM-dd HH\\:mm\\:ss}: ${message}"; fileTarget.ArchiveFileName = "${basedir}\\archives\\log.{#####}.txt"; fileTarget.ArchiveAboveSize = 10240000; fileTarget.ArchiveNumbering = ArchiveNumberingMode.Sequence; var rule = new LoggingRule("*", LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule); var errorTarget = new FileTarget(); config.AddTarget("errorfile", errorTarget); errorTarget.FileName = "${basedir}\\Errors.txt"; errorTarget.Layout = "${date:format=yyyy-MM-dd HH\\:mm\\:ss}: ${message}"; errorTarget.ArchiveFileName = "${basedir}\\archives\\log.{#####}.txt"; errorTarget.ArchiveAboveSize = 10240000; errorTarget.ArchiveNumbering = ArchiveNumberingMode.Sequence; var errorsRule = new LoggingRule("*", LogLevel.Error, errorTarget); config.LoggingRules.Add(errorsRule); LogManager.Configuration = config; return LogManager.GetCurrentClassLogger(); }
public static void ConfigureViaCode(LogLevel consoleLogLevel, LogLevel fileLogLevel) { // 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); // Step 3. Set target properties consoleTarget.Layout = @"${message} ${onexception:EXCEPTION\:${exception:format=tostring}}"; fileTarget.Layout = @"${date:format=yyyy-MM-dd HH\:mm\:ss.fff} [${level:uppercase=true}] ${message} ${onexception:EXCEPTION\:${exception:format=tostring}}"; fileTarget.FileName = "C:\\temp\\logs\\SpiderOpenQuant.${date:format=yyyy-MM-dd hh}.log"; fileTarget.ConcurrentWrites = false; fileTarget.KeepFileOpen = true; fileTarget.OpenFileCacheTimeout = 60; // Step 4. Define rules var rule1 = new LoggingRule("*", consoleLogLevel, consoleTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", fileLogLevel, fileTarget); config.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = config; }
private void configureLogger() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); consoleTarget.Layout = @"${date:format=HH\:MM\:ss} ${logger} ${message}"; fileTarget.FileName = "${basedir}/logs/${shortdate}.log"; fileTarget.EnableFileDelete = true; fileTarget.DeleteOldFileOnStartup = true; fileTarget.Layout = "${message}"; var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule2); LogManager.Configuration = config; log = LogManager.GetLogger("SeleniumTests"); }
private void SetupLogging() { // Step 1. Create configuration object LoggingConfiguration configuration = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration FileTarget fileTarget = new FileTarget(); configuration.AddTarget("file", fileTarget); NLogViewerTarget log_viewer_target = new NLogViewerTarget(); log_viewer_target.Name = "viewer"; log_viewer_target.Address = "udp://127.0.0.1:9999"; configuration.AddTarget("viewer", log_viewer_target); // Step 3. Set target properties fileTarget.FileName = "${basedir}/file.txt"; fileTarget.Layout = "${date} ${level} ${message}"; // Step 4. Define rules LoggingRule rule1 = new LoggingRule("*", LogLevel.Debug, fileTarget); configuration.LoggingRules.Add(rule1); LoggingRule rule2 = new LoggingRule("*", LogLevel.Trace, log_viewer_target); configuration.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = configuration; // Example usage log.Debug("Application started"); }
public void InitNLog() { // Step 1. Create configuration object NLog.Config.LoggingConfiguration gConfig = new NLog.Config.LoggingConfiguration(); // Step 2. Create targets and add them to the configuration NLog.Targets.ColoredConsoleTarget consoleTarget = new NLog.Targets.ColoredConsoleTarget(); gConfig.AddTarget("console", consoleTarget); NLog.Targets.FileTarget fileTarget = new NLog.Targets.FileTarget(); gConfig.AddTarget("file", fileTarget); // Step 3. Set target properties consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; fileTarget.FileName = System.IO.Directory.GetCurrentDirectory() + "/${shortdate}/${logger}.log"; fileTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; UnityEngine.Debug.Log(fileTarget.FileName); // Step 4. Define rules NLog.Config.LoggingRule rule1 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, consoleTarget); gConfig.LoggingRules.Add(rule1); NLog.Config.LoggingRule rule2 = new NLog.Config.LoggingRule("*", NLog.LogLevel.Debug, fileTarget); gConfig.LoggingRules.Add(rule2); // Step 5. Activate the configuration NLog.LogManager.Configuration = gConfig; }
private static void SetupLogging() { // Step 1. Create configuration object LoggingConfiguration config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); FileTarget fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); fileTarget.FileName = "${basedir}/file.txt"; // Step 3. Set target properties consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; fileTarget.Layout = "${date:format=HH\\:MM\\:ss} ${message}"; // Step 4. Define rules LoggingRule rule = new LoggingRule("*", LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule); rule = new LoggingRule("*", LogLevel.Debug, fileTarget); config.LoggingRules.Add(rule); // Step 5. Activate the configuration LogManager.Configuration = config; }
static LocalLogger() { // Creating new Logger from current class _logger = LogManager.GetLogger(nameof(LocalLogger)); var loggerFilePath = System.Configuration.ConfigurationManager.AppSettings["loggerFilePath"]; var loggerFileName = $"{LogFileName}.{DateTime.Now:yyy-MM-dd}.log"; //$"{Environment.CurrentDirectory}/{LogFileName}.{DateTime.Now:yyy-MM-dd}.log"; // File Target Configuration var logFileTarget = new FileTarget { Name = LogFileName, FileName = $"{loggerFilePath}/{loggerFileName}", Layout = string.Format("{0:yyy-MM-dd hh:mm} :: [{1}] :: {2} -> {3}", DateTime.Now, "${level}", "${message}", "${exception}") }; logFileTarget.ArchiveEvery = FileArchivePeriod.Hour; logFileTarget.ArchiveNumbering = ArchiveNumberingMode.Rolling; logFileTarget.ArchiveFileName = new SimpleLayout($"{LogFileName}_#####.log"); // Logging Rule Configuration var logRule = new LoggingRule("*", LogLevel.Info, logFileTarget); // New LoggingConfiguration Object var logConfig = new LoggingConfiguration(); // Configuring Target and Rules to LoggingConfiguration logConfig.AddTarget(LogFileName, logFileTarget); logConfig.LoggingRules.Add(logRule); // Setting new LoggingConfiguration LogManager.Configuration = logConfig; }
private static Target ConfigureFileLog(LoggingConfiguration config, string filename = "file.log") { Uri uri = new System.Uri(Assembly.GetExecutingAssembly().CodeBase); //Uri uri = new System.Uri(Directory.GetCurrentDirectory()); var baseDir = new DirectoryInfo(uri.AbsolutePath).Parent.Parent; string filepath = ""; if (baseDir.Exists) { filepath = Path.Combine(baseDir.FullName, "App_Data", "file.log"); } else { return(null); } NLog.Targets.FileTarget target = new FileTarget(); target.FileName = filepath; //target.Name = "f"; target.Layout = "${longdate} ${message}"; NLog.Config.LoggingRule rule = new NLog.Config.LoggingRule("*", LogLevel.Trace, target); config.AddTarget("file", target); config.LoggingRules.Add(rule); return(target); }
public void Initialize() { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); var logentriesTarget = new Le.LeTarget(); config.AddTarget("logentries", logentriesTarget); // Step 3. Set target properties fileTarget.FileName = "${specialfolder:folder=LocalApplicationData}/" + GlobalConstants.Paths.LogFile; fileTarget.Layout = layout; logentriesTarget.Layout = layout; // Step 4. Define rules var rule1 = new LoggingRule("*", LogLevel.Info, fileTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", LogLevel.Info, logentriesTarget); config.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = config; }
public static void LoadLoggerToLoggingConfig(LoggingConfiguration logConfig, IConfiguration Configuration,string sectionString) { var fileLoggerSection = Configuration.GetSection(sectionString).GetChildren(); foreach (var logging in fileLoggerSection) { var target = new FileTarget() { FileName = logging["fileName"], Name = logging["name"], Layout = logging["layoutFormat"] }; var minLevel = logging["minLevel"] != null ? LogLevel.FromString(logging["minLevel"]) : null; LoggingRule rule = null; if (minLevel != null) { rule = new LoggingRule(logging["namePattern"], minLevel, target); } else { rule = new LoggingRule(logging["namePattern"], target); } var useLevels = logging["logLevel"]; if(string.IsNullOrWhiteSpace(useLevels) == false) { var levels = useLevels.Split(','); foreach (var level in levels) { rule.EnableLoggingForLevel(LogLevel.FromString(level)); } } logConfig.AddTarget(target); logConfig.LoggingRules.Add(rule); } }
// ------------------------------------------ // Logs Management // ------------------------------------------ protected void SetupLogging() { var path = ConfigManager.GetInstance().Find("debug.log-file", null); if (null == path) { return; } LoggingConfiguration config = new LoggingConfiguration(); ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget(); consoleTarget.Layout = "${date:format=HH\\:MM\\:ss} ${logger} ${message}"; config.AddTarget("console", consoleTarget); FileTarget fileTarget = new FileTarget(); fileTarget.FileName = path; fileTarget.Layout = "${message}"; fileTarget.CreateDirs = true; config.AddTarget("file", fileTarget); LoggingRule rule1 = new LoggingRule("*", LogLevel.Info, consoleTarget); config.LoggingRules.Add(rule1); LoggingRule rule2 = new LoggingRule("*", LogLevel.Info, fileTarget); config.LoggingRules.Add(rule2); LoggingRule rule3 = new LoggingRule("*", LogLevel.Warn, consoleTarget); config.LoggingRules.Add(rule3); LoggingRule rule4 = new LoggingRule("*", LogLevel.Warn, fileTarget); config.LoggingRules.Add(rule4); // Ready LogManager.ReconfigExistingLoggers(); LogManager.Configuration = config; Host.Log(this, "STARTING LOGGING:" + fileTarget.FileName); }
public static void SetupLogging(LogLevel logLevel) { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var debuggerTarget = new DebuggerTarget(); config.AddTarget("debugger", debuggerTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); // Step 3. Set target properties debuggerTarget.Layout = @"${logger:shortName=True} - ${uppercase:${level}}: ${message}"; fileTarget.FileName = "${specialfolder:folder=MyDocuments}/Artemis/logs/${shortdate}.txt"; fileTarget.Layout = "${longdate}|${level:uppercase=true}|${logger}|${message} ${exception:format=tostring}"; fileTarget.EnableFileDelete = true; fileTarget.MaxArchiveFiles = 7; fileTarget.ArchiveEvery = FileArchivePeriod.Minute; // Step 4. Define rules var rule1 = new LoggingRule("*", logLevel, debuggerTarget); config.LoggingRules.Add(rule1); var rule2 = new LoggingRule("*", logLevel, fileTarget); config.LoggingRules.Add(rule2); // Step 5. Activate the configuration LogManager.Configuration = config; // Log as fatal so it always shows var logger = LogManager.GetCurrentClassLogger(); logger.Fatal("INFO: Set log level to {0}", logLevel); }
/// <summary> /// Configures NLog for to log to the specified target so that all messages /// above and including the specified level are output. /// </summary> /// <param name="target">The target to log all messages to.</param> /// <param name="minLevel">The minimal logging level.</param> public static void ConfigureForTargetLogging(Target target, LogLevel minLevel) { LoggingConfiguration config = new LoggingConfiguration(); LoggingRule rule = new LoggingRule("*", minLevel, target); config.LoggingRules.Add(rule); LogManager.Configuration = config; }
private void ConfigLogging() { var config = new LoggingConfiguration(); var target = new DebuggerTarget { Layout = @"${date:format=HH\\:MM\\:ss} ${logger} ${message}" }; var sqlTarget = new FileTarget { Layout = @"${date:format=HH\\:MM\\:ss} ${logger} ${message}", FileName = "sql.log" }; var rule = new LoggingRule( "*", LogLevel.Trace, target ); var sqlRule = new LoggingRule( "NHibernate", LogLevel.Trace, sqlTarget ); config.AddTarget( "sql", sqlTarget ); config.AddTarget( "debugger", target ); config.LoggingRules.Add( sqlRule ); config.LoggingRules.Add( rule ); LogManager.Configuration = config; }
private static void EnableFileLogging(RoslynInsertionToolOptions options) { var logConfig = LogManager.Configuration; // regular file logging var fileTarget = new NLog.Targets.FileTarget("file") { FileName = options.LogFileLocation, Layout = logConfig.Variables["VerboseLayout"] }; logConfig.AddTarget(fileTarget); logConfig.AddRule(NLog.LogLevel.Trace, NLog.LogLevel.Fatal, fileTarget); // exception logging var exceptionFilter = new NLog.Filters.ConditionBasedFilter() { Condition = "length('${exception}') > 0", Action = NLog.Filters.FilterResult.Ignore }; var exceptionFileTarget = new NLog.Targets.FileTarget("fileAsException") { FileName = options.LogFileLocation, Layout = logConfig.Variables["ExceptionVerboselayout"] }; var rule = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, exceptionFileTarget); rule.Filters.Add(exceptionFilter); logConfig.LoggingRules.Add(rule); logConfig.Reload(); }
public void UsingLoggingAspectWithNLogShouldUseNlogger() { // arrange - setup nlog LoggingConfiguration config = new LoggingConfiguration(); MemoryTarget memoryTarget = new MemoryTarget { Layout = @"${message}" }; config.AddTarget("memory", memoryTarget); LoggingRule rule = new LoggingRule("*", LogLevel.Debug, memoryTarget); config.LoggingRules.Add(rule); LogManager.Configuration = config; Mock<IConfigurationProvider> mock = new Mock<IConfigurationProvider>(); mock.Setup(provider => provider.ShouldLog(It.IsAny<LogAttribute>())).Returns(true); LogAttribute.ConfigurationProvider = mock.Object; // arrange - setup logger LogAttribute.Logger = new NLogLogger("memory"); // act Person person = new Person { Name = "test", Balance = 0.0d }; person.Should().NotBeNull(); // assert memoryTarget.Logs.Count.Should().Be(9, "because we called the logging 9 times"); }
public static void Configure() { // Step 1. Create configuration object var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); var fileTarget = new FileTarget(); config.AddTarget("file", fileTarget); // Step 3. Set target properties consoleTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"; fileTarget.FileName = "${basedir}/SimplePerformanceMeter.txt"; fileTarget.Layout = "${message}"; // 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; }
public LoggingSystem([NotNull] IEnvironment environment) { if (environment == null) throw new ArgumentNullException("environment"); config = new LoggingConfiguration(); LogManager.Configuration = config; // rolling custom archival because NLog options failed me. var currentLogDir = Path.Combine(environment.FullPathToRootDataDirectory, "Logs"); if (!Directory.Exists(currentLogDir)) Directory.CreateDirectory(currentLogDir); var archiveLogDir = Path.Combine(currentLogDir, "Archive"); if (!Directory.Exists(archiveLogDir)) Directory.CreateDirectory(archiveLogDir); MoveOldLogToArchive(currentLogDir, archiveLogDir); TrimOlgLogFiles(archiveLogDir, maxMegabytes: 50); var currentFileName = Time.Clock.LocalNow.ToString("yyy-MM-dd_HH-mm-ss-ffffff") + ".txt"; FullPathToCurrentLogFile = currentFileName; var fileTarget = new FileTarget { ArchiveNumbering = ArchiveNumberingMode.DateAndSequence, KeepFileOpen = true, FileName = Path.Combine(currentLogDir, currentFileName), }; globalrule = new LoggingRule("*", LogLevel.Debug, fileTarget); }
/// <summary> /// Starts the application /// </summary> public static void Start() { #if DEBUG // Setup the logging view for Sentinel - http://sentinel.codeplex.com var sentinalTarget = new NLogViewerTarget() { Name = "sentinal", Address = "udp://127.0.0.1:9999" }; var sentinalRule = new LoggingRule("*", LogLevel.Trace, sentinalTarget); LogManager.Configuration.AddTarget("sentinal", sentinalTarget); LogManager.Configuration.LoggingRules.Add(sentinalRule); // Setup the logging view for Harvester - http://harvester.codeplex.com var harvesterTarget = new OutputDebugStringTarget() { Name = "harvester", Layout = new Log4JXmlEventLayout() }; var harvesterRule = new LoggingRule("*", LogLevel.Trace, harvesterTarget); LogManager.Configuration.AddTarget("harvester", harvesterTarget); LogManager.Configuration.LoggingRules.Add(harvesterRule); LogManager.ReconfigExistingLoggers(); #endif // Configure this.Log() for NLog Log.InitializeWith<NLogLog>(); }
/// <summary> /// Constructs an instance of DependencyRegistry /// </summary> public DependencyRegistry(ConfigSettings configSettings) { string logFileTemplate = configSettings.LogFileTemplate ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "default.log"); string dataDirectory = configSettings.DataDirectory ?? Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "configdata"); LogLevel logLevel = GetMatchingLogLevelOrDefault(configSettings.LogLevel) ?? LogLevel.Info; For<IRepository<IJsonEntity<ConfigRoot>>>() .Singleton() .Use(new DurableMemoryRepository<ConfigRoot>(dataDirectory, new FileSystemFacade())); var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); fileTarget.Name = "LogFile"; fileTarget.FileName = logFileTemplate; config.AddTarget(fileTarget.Name, fileTarget); var loggingRule = new LoggingRule("*", logLevel, fileTarget); config.LoggingRules.Add(loggingRule); LogManager.Configuration = config; For<ILogger>() .Singleton() .Use(l => new LoggerAdapter(LogManager.GetLogger(GetType().Namespace))); // Ask StructureMap to always do property injection for certain properties // TODO: remove this? SetAllProperties(policy => policy.OfType<ILogger>()); }
public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory) { #if DNX451 var config = new LoggingConfiguration(); // Step 2. Create targets and add them to the configuration var consoleTarget = new ColoredConsoleTarget(); config.AddTarget("console", consoleTarget); consoleTarget.Layout = @"${date:format=HH\\:MM\\:ss} ${ndc} ${logger} ${message} "; var rule1 = new LoggingRule("*", NLog.LogLevel.Debug, consoleTarget); config.LoggingRules.Add(rule1); loggerFactory.AddNLog(new global::NLog.LogFactory(config)); #endif app.UseErrorPage() .UseStaticFiles() .UseIdentity() .UseFacebookAuthentication() .UseGoogleAuthentication() .UseTwitterAuthentication() .UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller}/{action}/{id?}", defaults: new { controller = "Home", action = "Index" }); }); //Populates the Admin user and role SampleData.InitializeIdentityDatabaseAsync(app.ApplicationServices).Wait(); }
static Log() { #if DEBUG // Setup the logging view for Sentinel - http://sentinel.codeplex.com var sentinalTarget = new NLogViewerTarget { Name = "sentinal", Address = "udp://127.0.0.1:9999" }; var sentinalRule = new LoggingRule("*", LogLevel.Trace, sentinalTarget); LogManager.Configuration.AddTarget("sentinal", sentinalTarget); LogManager.Configuration.LoggingRules.Add(sentinalRule); // Setup the logging view for Harvester - http://harvester.codeplex.com var harvesterTarget = new OutputDebugStringTarget() { Name = "harvester", Layout = new Log4JXmlEventLayout() }; var harvesterRule = new LoggingRule("*", LogLevel.Trace, harvesterTarget); LogManager.Configuration.AddTarget("harvester", harvesterTarget); LogManager.Configuration.LoggingRules.Add(harvesterRule); #endif LogManager.ReconfigExistingLoggers(); Instance = LogManager.GetCurrentClassLogger(); }
/* Configure the logger programmatically. */ static NLoggerUtil() { var config = new LoggingConfiguration(); string path = "GhostFactor.log"; if (toDesktop) path = desktopPath + path; var target = new FileTarget { FileName = path }; // Add a file target where all the log shall go to. config.AddTarget("file", target); // Add a rule that any information higher than debug goes to the file. var rule = new LoggingRule("*", LogLevel.Debug, target); config.LoggingRules.Add(rule); // Also log fatal logs to another file. string fatalPath = "GhostFactorFatal.log"; if (toDesktop) fatalPath = desktopPath + fatalPath; var fatalTarget = new FileTarget() { FileName = fatalPath }; var fatalRule = new LoggingRule("*", LogLevel.Fatal, fatalTarget); config.LoggingRules.Add(fatalRule); LogManager.Configuration = config; }
public void SetUp() { var config = new LoggingConfiguration(); var consoleTarget = new ColoredConsoleTarget {Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"}; var rule1 = new LoggingRule("*", LogLevel.Trace, consoleTarget); config.LoggingRules.Add(rule1); LogManager.Configuration = config; }
public static void ConfigureForConsoleLogging(LogLevel minLevel) { ConsoleTarget consoleTarget = new ConsoleTarget(); LoggingConfiguration config = new LoggingConfiguration(); LoggingRule rule = new LoggingRule("*", minLevel, consoleTarget); config.LoggingRules.Add(rule); LogManager.Configuration = config; }
private void RegisterDebuggerTarget(IUnityContainer container) { var debuggerTarget = new DebuggerTarget() { Layout = Layout.FromString(Constants.Logging.DefaultLayout) }; var rule1 = new LoggingRule("*", LogLevel.Debug, debuggerTarget); container.RegisterInstance("Debugger", rule1); }
public static void Inizialize() { var config = new LoggingConfiguration(); var fileTarget = new FileTarget(); fileTarget.FileName = "${basedir}/Logs/${logger}.txt"; fileTarget.Layout = @"${date:format=HH\:mm\:ss} ${logger} ${message}"; var rule = new LoggingRule("*", LogLevel.Trace, fileTarget); config.LoggingRules.Add(rule); LogManager.Configuration = config; }
private static void RegisterDebugger() { DebuggerTarget target = new DebuggerTarget(); target.Name = "debuggerLogger"; target.Layout = "[${level}] [${threadid}] ${logger}: ${message} ${onexception:inner=${newline}${newline}${exception:format=ToString}${newline}}"; var loggingRule = new LoggingRule("*", LogLevel.Trace, target); LogManager.Configuration.AddTarget("debugger", target); LogManager.Configuration.LoggingRules.Add(loggingRule); }
private void RegisterFileTarget(IUnityContainer container) { var fileTarget = new FileTarget() { FileName = "${basedir}/Logs/" + SessionId + "/${level}.log", Layout = Layout.FromString(Constants.Logging.DefaultLayout) }; var rule2 = new LoggingRule("*", LogLevel.Debug, fileTarget); container.RegisterInstance("File", rule2); }
private static void ConfigurePaperTrailLog(LoggingConfiguration config) { Syslog papertrail = new Syslog(); papertrail.Port = 49730; // papertrail.Name = "TomaskoExtractor"; papertrail.Sender = "MSCRM-Extractor"; papertrail.SyslogServer = "logs.papertrailapp.com"; papertrail.Facility = Syslog.SyslogFacility.Local7; var syslogRule = new NLog.Config.LoggingRule("*", LogLevel.Trace, papertrail); config.AddTarget("PaperTrailLogging", papertrail); config.LoggingRules.Add(syslogRule); }
public static NLog.Config.LoggingConfiguration GetConfiguration() { NLog.Config.ConfigurationItemFactory.Default.Targets.RegisterDefinition("AzureTableStorageTarget", typeof(NLog.Extensions.AzureTableStorage.AzureTableStorageTarget)); NLog.Config.ConfigurationItemFactory.Default.Targets.RegisterDefinition("AzureTableStorageTargetCustom", typeof(NLogAzureStorageTarget)); NLog.Config.ConfigurationItemFactory.Default.Targets.RegisterDefinition("AzureTableStorageTargetCustom", typeof(NLog.Targets.ConsoleTarget)); NLog.Config.LoggingConfiguration config = new NLog.Config.LoggingConfiguration(); var targetAzure = new NLog.Extensions.AzureTableStorage.AzureTableStorageTarget(); targetAzure.Layout = "${json-encode:jsonEncode=True:inner=${message}}"; targetAzure.Name = "tableStorage"; targetAzure.ConnectionString = JehovaJireh.Configuration.CloudConfiguration.GetConnectionString("LogStorageConnectionString"); targetAzure.TableName = "logging"; config.AddTarget("tableStorage", targetAzure); var targetAzureCustom = new NLogAzureStorageTarget(); //targetAzureCustom.Layout = "${json-encode:jsonEncode=True:inner=${message}}"; targetAzureCustom.Name = "tableStorageCustom"; targetAzureCustom.TableStorageConnectionStringName = "LogStorageConnectionString"; targetAzureCustom.TableName = "logging"; config.AddTarget("tableStorageCustom", targetAzure); var targetConsole = new NLog.Targets.ConsoleTarget(); targetConsole.Layout = "${json-encode:jsonEncode=True:inner=${message}}"; targetConsole.Name = "console"; config.AddTarget("console", targetConsole); var ruleNHibernate = new NLog.Config.LoggingRule("NHibernate*", NLog.LogLevel.Debug, targetAzureCustom); var ruleApplication = new NLog.Config.LoggingRule("JehovaJireh*", NLog.LogLevel.Trace, targetAzureCustom); config.LoggingRules.Add(ruleNHibernate); config.LoggingRules.Add(ruleApplication); var ruleConsole = new NLog.Config.LoggingRule("*", NLog.LogLevel.Trace, targetConsole); config.LoggingRules.Add(ruleConsole); return(config); }
/// <summary> /// Parse {Logger} xml element /// </summary> /// <param name="loggerElement"></param> /// <param name="rulesCollection">Rules are added to this parameter.</param> private void ParseLoggerElement(NLogXmlElement loggerElement, IList <LoggingRule> rulesCollection) { loggerElement.AssertName("logger"); var namePattern = loggerElement.GetOptionalAttribute("name", "*"); var enabled = loggerElement.GetOptionalBooleanAttribute("enabled", true); if (!enabled) { InternalLogger.Debug("The logger named '{0}' are disabled"); return; } var rule = new LoggingRule(); string appendTo = loggerElement.GetOptionalAttribute("appendTo", null); if (appendTo == null) { appendTo = loggerElement.GetOptionalAttribute("writeTo", null); } rule.LoggerNamePattern = namePattern; if (appendTo != null) { foreach (string t in appendTo.Split(',')) { string targetName = t.Trim(); Target target = FindTargetByName(targetName); if (target != null) { rule.Targets.Add(target); } else { throw new NLogConfigurationException("Target " + targetName + " not found."); } } } rule.Final = loggerElement.GetOptionalBooleanAttribute("final", false); string levelString; if (loggerElement.AttributeValues.TryGetValue("level", out levelString)) { LogLevel level = LogLevel.FromString(levelString); rule.EnableLoggingForLevel(level); } else if (loggerElement.AttributeValues.TryGetValue("levels", out levelString)) { levelString = CleanSpaces(levelString); string[] tokens = levelString.Split(','); foreach (string token in tokens) { if (!string.IsNullOrEmpty(token)) { LogLevel level = LogLevel.FromString(token); rule.EnableLoggingForLevel(level); } } } else { int minLevel = 0; int maxLevel = LogLevel.MaxLevel.Ordinal; string minLevelString; string maxLevelString; if (loggerElement.AttributeValues.TryGetValue("minLevel", out minLevelString)) { minLevel = LogLevel.FromString(minLevelString).Ordinal; } if (loggerElement.AttributeValues.TryGetValue("maxLevel", out maxLevelString)) { maxLevel = LogLevel.FromString(maxLevelString).Ordinal; } for (int i = minLevel; i <= maxLevel; ++i) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } } var children = loggerElement.Children.ToList(); foreach (var child in children) { switch (child.LocalName.ToUpper(CultureInfo.InvariantCulture)) { case "FILTERS": this.ParseFilters(rule, child); break; case "LOGGER": this.ParseLoggerElement(child, rule.ChildRules); break; } } rulesCollection.Add(rule); }
private void ConfigureRulesFromElement(LoggingConfiguration config, LoggingRuleCollection rules, XmlElement element) { if (element == null) { return; } foreach (XmlElement el in PropertyHelper.GetChildElements(element, "logger")) { XmlElement ruleElement = el; LoggingRule rule = new LoggingRule(); string namePattern = GetCaseInsensitiveAttribute(ruleElement, "name"); if (namePattern == null) { namePattern = "*"; } string appendTo = GetCaseInsensitiveAttribute(ruleElement, "appendTo"); if (appendTo == null) { appendTo = GetCaseInsensitiveAttribute(ruleElement, "writeTo"); } rule.LoggerNamePattern = namePattern; if (appendTo != null) { foreach (string t in appendTo.Split(',')) { string targetName = t.Trim(); Target target = config.FindTargetByName(targetName); if (target != null) { rule.Targets.Add(target); } else { throw new NLogConfigurationException("Target " + targetName + " not found."); } } } rule.Final = false; if (HasCaseInsensitiveAttribute(ruleElement, "final")) { rule.Final = true; } if (HasCaseInsensitiveAttribute(ruleElement, "level")) { LogLevel level = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "level")); rule.EnableLoggingForLevel(level); } else if (HasCaseInsensitiveAttribute(ruleElement, "levels")) { string levelsString = GetCaseInsensitiveAttribute(ruleElement, "levels"); levelsString = CleanWhitespace(levelsString); string[] tokens = levelsString.Split(','); foreach (string s in tokens) { if (s != "") { LogLevel level = LogLevel.FromString(s); rule.EnableLoggingForLevel(level); } } } else { int minLevel = 0; int maxLevel = LogLevel.MaxLevel.Ordinal; if (HasCaseInsensitiveAttribute(ruleElement, "minlevel")) { minLevel = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "minlevel")).Ordinal; } if (HasCaseInsensitiveAttribute(ruleElement, "maxlevel")) { maxLevel = LogLevel.FromString(GetCaseInsensitiveAttribute(ruleElement, "maxlevel")).Ordinal; } for (int i = minLevel; i <= maxLevel; ++i) { rule.EnableLoggingForLevel(LogLevel.FromOrdinal(i)); } } foreach (XmlElement el2 in PropertyHelper.GetChildElements(ruleElement, "filters")) { ConfigureRuleFiltersFromXmlElement(rule, el2); } ConfigureRulesFromElement(config, rule.ChildRules, ruleElement); rules.Add(rule); } }
/// <summary> /// Adds an instance of type LoggingRule to the end of this LoggingRuleCollection. /// </summary> /// <param name="value"> /// The LoggingRule to be added to the end of this LoggingRuleCollection. /// </param> public virtual void Add(LoggingRule value) { this.List.Add(value); }
private void AddLoggingRulesThreadSafe(LoggingRule rule) { lock (LoggingRules) LoggingRules.Add(rule); }
/// <summary> /// Determines whether a specfic LoggingRule value is in this LoggingRuleCollection. /// </summary> /// <param name="value"> /// The LoggingRule value to locate in this LoggingRuleCollection. /// </param> /// <returns> /// true if value is found in this LoggingRuleCollection; /// false otherwise. /// </returns> public virtual bool Contains(LoggingRule value) { return(this.List.Contains(value)); }
/// <summary> /// Return the zero-based index of the first occurrence of a specific value /// in this LoggingRuleCollection /// </summary> /// <param name="value"> /// The LoggingRule value to locate in the LoggingRuleCollection. /// </param> /// <returns> /// The zero-based index of the first occurrence of the _ELEMENT value if found; /// -1 otherwise. /// </returns> public virtual int IndexOf(LoggingRule value) { return(this.List.IndexOf(value)); }
/// <summary> /// Inserts an element into the LoggingRuleCollection at the specified index /// </summary> /// <param name="index"> /// The index at which the LoggingRule is to be inserted. /// </param> /// <param name="value"> /// The LoggingRule to insert. /// </param> public virtual void Insert(int index, LoggingRule value) { this.List.Insert(index, value); }
/// <summary> /// Removes the first occurrence of a specific LoggingRule from this LoggingRuleCollection. /// </summary> /// <param name="value"> /// The LoggingRule value to remove from this LoggingRuleCollection. /// </param> public virtual void Remove(LoggingRule value) { this.List.Remove(value); }
public DynamicLogLevelFilter(LoggingRule loggingRule, SimpleLayout levelFilter) { _loggingRule = loggingRule; _levelFilter = levelFilter; _activeFilter = new KeyValuePair <string, bool[]>(string.Empty, LoggingRuleLevelFilter.Off.LogLevels); }