Beispiel #1
0
        public void CountersIncrementSeperately()
        {
            var events = new List <LogEvent>();

            var log = new LoggerConfiguration()
                      .WriteTo.Sink(new DelegatingSink(e => events.Add(e)))
                      .CreateLogger();

            var counter1 = log.CountOperation("TestCounter1", directWrite: false);
            var counter2 = log.CountOperation("TestCounter2", directWrite: false);

            // increment counter1 5 times
            for (int i = 0; i < 5; i++)
            {
                counter1.Increment();
            }

            // increment counter2 10 times
            for (int i = 0; i < 10; i++)
            {
                counter2.Increment();
            }

            counter1.Write();
            counter2.Write();

            var counter1Literal = (long)events[0].Properties["CounterValue"].LiteralValue();
            var counter2Literal = (long)events[1].Properties["CounterValue"].LiteralValue();

            Assert.AreEqual(5, counter1Literal);
            Assert.AreEqual(10, counter2Literal);
        }
Beispiel #2
0
        static void Main()
        {
            var logger = new LoggerConfiguration()
                         .MinimumLevel.Debug()
                         .WriteTo.ColoredConsole(
                outputTemplate: "{Timestamp:HH:mm:ss} ({ThreadId}) [{Level}] {Message}{NewLine}{Exception}")
                         .WriteTo.Trace()
                         .Enrich.With(new ThreadIdEnricher(), new MachineNameEnricher())
                         .CreateLogger();


            using (logger.BeginTimedOperation("Time a thread sleep for 2 seconds."))
            {
                Thread.Sleep(1000);
                using (logger.BeginTimedOperation("And inside we try a Task.Delay for 2 seconds."))
                {
                    Task.Delay(2000).Wait();
                }
                Thread.Sleep(1000);
            }

            using (logger.BeginTimedOperation("Using a passed in identifier", "test-loop"))
            {
                // ReSharper disable once NotAccessedVariable
                var a = "";
                for (var i = 0; i < 1000; i++)
                {
                    a += "b";
                }
            }

            // Exceed a limit
            using (logger.BeginTimedOperation("This should execute within 1 second.", null, LogEventLevel.Debug, TimeSpan.FromSeconds(1)))
            {
                Thread.Sleep(1100);
            }

            // Gauge
            var queue = new Queue <int>();
            var gauge = logger.GaugeOperation("queue", "item(s)", () => queue.Count());

            gauge.Write();

            queue.Enqueue(20);

            gauge.Write();

            queue.Dequeue();

            gauge.Write();

            // Counter
            var counter = logger.CountOperation("counter", "operation(s)", true, LogEventLevel.Debug);

            counter.Increment();
            counter.Increment();
            counter.Increment();
            counter.Decrement();

            System.Console.WriteLine("Press a key to exit.");
            System.Console.ReadKey(true);
        }
Beispiel #3
0
        static void Main(string[] args)
        {
            var logger = new LoggerConfiguration()
                         .MinimumLevel.Debug()
                         .WriteTo.ColoredConsole(
                outputTemplate: "{Timestamp:HH:mm:ss} ({ThreadId}) [{Level}] {Message}{NewLine}{Exception}")
                         .WriteTo.Trace()
                         .WriteTo.NewRelic(applicationName: "Serilog.Sinks.NewRelic.Sample")
                         .Enrich.With(new ThreadIdEnricher(), new MachineNameEnricher())
                         .CreateLogger();

            logger.Information("This is a simple information message {Property1}", 100);

            // Adding a custom transaction

            using (logger.BeginTimedOperation("Time a thread sleep for 2 seconds."))
            {
                Thread.Sleep(1000);
                using (logger.BeginTimedOperation("And inside we try a Task.Delay for 2 seconds."))
                {
                    Task.Delay(2000).Wait();
                }
                Thread.Sleep(1000);
            }

            using (logger.BeginTimedOperation("Using a passed in identifier", "test-loop"))
            {
                // ReSharper disable once NotAccessedVariable
                var a = "";
                for (var i = 0; i < 1000; i++)
                {
                    a += "b";
                }
            }

            // Exceed a limit
            using (logger.BeginTimedOperation("This should execute within 1 second.", null, LogEventLevel.Debug, TimeSpan.FromSeconds(1)))
            {
                Thread.Sleep(1100);
            }

            // Gauge

            var queue = new Queue <int>();
            var gauge = logger.GaugeOperation("queue", "item(s)", () => queue.Count());

            gauge.Write();

            queue.Enqueue(20);

            gauge.Write();

            queue.Dequeue();

            gauge.Write();

            // Counter
            var counter = logger.CountOperation("counter", "operation(s)", true, LogEventLevel.Debug, resolution: 2);

            counter.Increment();
            counter.Increment();
            counter.Increment();
            counter.Decrement();

            // Throw Exception
            try
            {
                throw new ApplicationException("This is an exception raised to test the New Relic API");
            }
            catch (Exception ex)
            {
                logger.Error(ex, "Error whilst testing the Serilog.Sinks.NewRelic.Sample");
            }



            System.Console.WriteLine("Press a key to exit.");
            System.Console.ReadKey(true);
        }
Beispiel #4
0
        public static void Main()
        {
            var logger = new LoggerConfiguration()
                         .MinimumLevel.Verbose()
                         .WriteTo.Console(outputTemplate: "{Timestamp:HH:mm:ss} ({ThreadId}) [{Level}] {Message}{NewLine}{Exception}")
                         .WriteTo.NewRelic("NewRelicSinkDev", "SerilogDev")
                         .Enrich.WithMachineName()
                         .Enrich.WithThreadId()
                         .CreateLogger();

            logger.ForContext(PropertyNameConstants.TransactionName, "test::trans")
            .Information("Message in a transaction");

            const string template = "This is a simple {Level} message {Val}";

            logger.Verbose(template, LogEventLevel.Verbose, (int)LogEventLevel.Verbose);
            logger.Debug(template, LogEventLevel.Debug, (int)LogEventLevel.Debug);
            logger.Information(template, LogEventLevel.Information, (int)LogEventLevel.Information);
            logger.Warning(template, LogEventLevel.Warning, (int)LogEventLevel.Warning);

            // Adding a custom transaction

            using (logger.BeginTimedOperation("Time a thread sleep for 2 seconds."))
            {
                Thread.Sleep(1000);
                using (logger.BeginTimedOperation("And inside we try a Task.Delay for 2 seconds."))
                {
                    Task.Delay(2000).Wait();
                }

                Thread.Sleep(1000);
            }

            using (logger.BeginTimedOperation("Using a passed in identifier", "test-loop"))
            {
                // ReSharper disable once NotAccessedVariable
                var a = "";
                for (var i = 0; i < 1000; i++)
                {
                    a += "b";
                }
            }

            // Exceed a limit
            using (logger.BeginTimedOperation("This should execute within 1 second.", null, LogEventLevel.Debug,
                                              TimeSpan.FromSeconds(1)))
            {
                Thread.Sleep(1100);
            }

            // Gauge
            var queue = new Queue <int>();
            var gauge = logger.GaugeOperation("queue", "item(s)", () => queue.Count);

            gauge.Write();

            queue.Enqueue(20);

            gauge.Write();

            queue.Dequeue();

            gauge.Write();

            // Counter
            var counter = logger.CountOperation("counter", "operation(s)", true, LogEventLevel.Debug, resolution: 2);

            counter.Increment();
            counter.Increment();
            counter.Increment();
            counter.Decrement();

            // Throw Exception
            try
            {
                throw new ApplicationException("This is an exception raised to test the New Relic API");
            }
            catch (Exception ex)
            {
                logger.Error(ex, "Error whilst testing the Serilog.Sinks.NewRelic.Sample");
                logger.Error("A templated test message notifying of an error. Value {val}", 1);
            }

            logger.Dispose();
            Console.WriteLine("Press a key to exit.");
            Console.ReadKey(true);
        }
        static void Main(string[] args)
        {
            var logger = new LoggerConfiguration()
                .MinimumLevel.Debug()
                .WriteTo.ColoredConsole(
                    outputTemplate: "{Timestamp:HH:mm:ss} ({ThreadId}) [{Level}] {Message}{NewLine}{Exception}")
                .WriteTo.Trace()
                .WriteTo.NewRelic(applicationName: "Serilog.Sinks.NewRelic.Sample")
                .Enrich.With(new ThreadIdEnricher(), new MachineNameEnricher())
                .CreateLogger();

            logger.Information("This is a simple information message {Property1}",100);

            // Adding a custom transaction

            using (logger.BeginTimedOperation("Time a thread sleep for 2 seconds."))
            {
                Thread.Sleep(1000);
                using (logger.BeginTimedOperation("And inside we try a Task.Delay for 2 seconds."))
                {
                    Task.Delay(2000).Wait();
                }
                Thread.Sleep(1000);
            }

            using (logger.BeginTimedOperation("Using a passed in identifier", "test-loop"))
            {
                // ReSharper disable once NotAccessedVariable
                var a = "";
                for (var i = 0; i < 1000; i++)
                {
                    a += "b";
                }
            }

            // Exceed a limit
            using (logger.BeginTimedOperation("This should execute within 1 second.", null, LogEventLevel.Debug, TimeSpan.FromSeconds(1)))
            {
                Thread.Sleep(1100);
            }

            // Gauge

            var queue = new Queue<int>();
            var gauge = logger.GaugeOperation("queue", "item(s)", () => queue.Count());

            gauge.Write();

            queue.Enqueue(20);

            gauge.Write();

            queue.Dequeue();

            gauge.Write();

            // Counter
            var counter = logger.CountOperation("counter", "operation(s)", true, LogEventLevel.Debug, resolution: 2);
            counter.Increment();
            counter.Increment();
            counter.Increment();
            counter.Decrement();

            // Throw Exception
            try
            {
                throw new ApplicationException("This is an exception raised to test the New Relic API");
            }
            catch (Exception ex)
            {
               logger.Error(ex, "Error whilst testing the Serilog.Sinks.NewRelic.Sample");
            }

            System.Console.WriteLine("Press a key to exit.");
            System.Console.ReadKey(true);
        }