Represents a logging rule. An equivalent of <logger /> configuration element.
Beispiel #1
1
        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;
      }
Beispiel #3
0
    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;
    }
Beispiel #4
0
        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");
        }
Beispiel #7
0
        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");
        }
Beispiel #8
0
    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;
        }
Beispiel #11
0
        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);
        }
Beispiel #12
0
        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);
    }
Beispiel #15
0
        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);
        }
Beispiel #16
0
 /// <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;
 }
Beispiel #17
0
        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");
        }
Beispiel #20
0
        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>()); 
        }
Beispiel #24
0
        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();
        }
Beispiel #25
0
        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();
        }
Beispiel #26
0
        /* 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;
        }
Beispiel #29
0
 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);
 }
Beispiel #30
0
 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;
 }
Beispiel #31
0
        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);
        }
Beispiel #32
0
 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);
 }
Beispiel #33
0
        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);
        }
Beispiel #34
0
        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);
            }
        }
Beispiel #37
0
 /// <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);
 }
Beispiel #39
0
 /// <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));
 }
Beispiel #40
0
 /// <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));
 }
Beispiel #41
0
 /// <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);
 }
Beispiel #42
0
 /// <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);
 }
Beispiel #43
0
 public DynamicLogLevelFilter(LoggingRule loggingRule, SimpleLayout levelFilter)
 {
     _loggingRule  = loggingRule;
     _levelFilter  = levelFilter;
     _activeFilter = new KeyValuePair <string, bool[]>(string.Empty, LoggingRuleLevelFilter.Off.LogLevels);
 }