Exemple #1
0
        public void OnOpenedLifecycleHookCanWrapUnderlyingStream()
        {
            var gzipWrapper = new GZipHooks();

            using (var tmp = TempFolder.ForCaller())
            {
                var path = tmp.AllocateFilename("txt");
                var evt  = Some.LogEvent("Hello, world!");

                using (var sink = new FileSink(path, new JsonFormatter(), null, null, false, gzipWrapper))
                {
                    sink.Emit(evt);
                    sink.Emit(evt);
                }

                // Ensure the data was written through the wrapping GZipStream, by decompressing and comparing against
                // what we wrote
                List <string> lines;
                using (var textStream = new MemoryStream())
                {
                    using (var fs = System.IO.File.OpenRead(path))
                        using (var decompressStream = new GZipStream(fs, CompressionMode.Decompress))
                        {
                            decompressStream.CopyTo(textStream);
                        }

                    textStream.Position = 0;
                    lines = textStream.ReadAllLines();
                }

                Assert.Equal(2, lines.Count);
                Assert.Contains("Hello, world!", lines[0]);
            }
        }
Exemple #2
0
        /// <summary>
        /// Emit the provided log event to the sink.
        /// </summary>
        /// <param name="logEvent">The log event to write.</param>
        /// <remarks>Events that come in out-of-order (e.g. around the rollovers)
        /// may end up written to a later file than their timestamp
        /// would indicate.</remarks>
        public void Emit(LogEvent logEvent)
        {
            if (logEvent == null)
            {
                throw new ArgumentNullException("logEvent");
            }

            lock (_syncRoot)
            {
                if (_isDisposed)
                {
                    throw new ObjectDisposedException("The rolling file has been disposed.");
                }

                AlignCurrentFileTo(Clock.DateTimeNow);

                // If the file was unable to be opened on the last attempt, it will remain
                // null until the next checkpoint passes, at which time another attempt will be made to
                // open it.
                if (_currentFile != null)
                {
                    _currentFile.Emit(logEvent);
                }
            }
        }
Exemple #3
0
        static void WriteTwoEventsAndCheckOutputFileLength(long?maxBytes, Encoding encoding)
        {
            using (var tmp = TempFolder.ForCaller())
            {
                var path = tmp.AllocateFilename("txt");
                var evt  = Some.LogEvent("Irrelevant as it will be replaced by the formatter");
                var actualEventOutput = "x";
                var formatter         = new FixedOutputFormatter(actualEventOutput);
                var eventOuputLength  = encoding.GetByteCount(actualEventOutput);

                using (var sink = new FileSink(path, formatter, maxBytes, encoding: encoding))
                {
                    sink.Emit(evt);
                }
                var size = new FileInfo(path).Length;
                Assert.Equal(encoding.GetPreamble().Length + eventOuputLength, size);

                //write a second event to the same file
                using (var sink = new FileSink(path, formatter, maxBytes, encoding: encoding))
                {
                    sink.Emit(evt);
                }

                size = new FileInfo(path).Length;
                Assert.Equal(encoding.GetPreamble().Length + eventOuputLength * 2, size);
            }
        }
Exemple #4
0
        public static void OnOpenedLifecycleHookCanWriteFileHeader()
        {
            using (var tmp = TempFolder.ForCaller())
            {
                var headerWriter = new FileHeaderWriter("This is the file header");

                var path = tmp.AllocateFilename("txt");
                using (new FileSink(path, new JsonFormatter(), null, new UTF8Encoding(false), false, headerWriter))
                {
                    // Open and write header
                }

                using (var sink = new FileSink(path, new JsonFormatter(), null, new UTF8Encoding(false), false, headerWriter))
                {
                    // Length check should prevent duplicate header here
                    sink.Emit(Some.LogEvent());
                }

                var lines = System.IO.File.ReadAllLines(path);

                Assert.Equal(2, lines.Length);
                Assert.Equal(headerWriter.Header, lines[0]);
                Assert.Equal('{', lines[1][0]);
            }
        }
Exemple #5
0
        public void FileControllerGetsCorrectString()
        {
            bool fileControllerGotLog = false;

            var fileController = new Mock <IFileController>();

            fileController.Setup(f => f.AppendLogEntry("this is correct log"))
            .Callback(() => fileControllerGotLog = true);

            var sink = new FileSink(fileController.Object);

            sink.Emit("this is not correct log", Enums.LogLevel.Critical);

            Assert.False(fileControllerGotLog);

            sink.Emit("this is correct log", Enums.LogLevel.Trace);

            Assert.True(fileControllerGotLog);
        }
Exemple #6
0
        public void FileIsWrittenIfNonexistent()
        {
            using (var tmp = TempFolder.ForCaller())
            {
                var nonexistent = tmp.AllocateFilename("txt");
                var evt         = Some.LogEvent("Hello, world!");

                using (var sink = new FileSink(nonexistent, new JsonFormatter(), null))
                {
                    sink.Emit(evt);
                }

                var lines = System.IO.File.ReadAllLines(nonexistent);
                Assert.Contains("Hello, world!", lines[0]);
            }
        }
Exemple #7
0
        // Simplifications:
        // Events that come in out-of-order (e.g. around the rollovers)
        // may end up written to a later file than their timestamp
        // would indicate.
        public void Emit(LogEvent logEvent)
        {
            if (logEvent == null)
            {
                throw new ArgumentNullException("logEvent");
            }

            lock (_syncRoot)
            {
                if (_isDisposed)
                {
                    throw new ObjectDisposedException("The rolling file has been disposed.");
                }

                AlignCurrentFileTo(logEvent.Timestamp);
                _currentFile.Emit(logEvent);
            }
        }
Exemple #8
0
        public void WhenLimitIsNotSpecifiedFileSizeIsNotRestricted()
        {
            const int maxBytes      = 5000;
            const int eventsToLimit = 10;

            using (var tmp = TempFolder.ForCaller())
            {
                var path = tmp.AllocateFilename("txt");
                var evt  = Some.LogEvent(new string('n', maxBytes / eventsToLimit));

                using (var sink = new FileSink(path, new JsonFormatter(), null))
                {
                    for (var i = 0; i < eventsToLimit * 2; i++)
                    {
                        sink.Emit(evt);
                    }
                }

                var size = new FileInfo(path).Length;
                Assert.True(size > maxBytes * 2);
            }
        }
Exemple #9
0
        public void FileIsAppendedToWhenAlreadyCreated()
        {
            using (var tmp = TempFolder.ForCaller())
            {
                var path = tmp.AllocateFilename("txt");
                var evt  = Some.LogEvent("Hello, world!");

                using (var sink = new FileSink(path, new JsonFormatter(), null))
                {
                    sink.Emit(evt);
                }

                using (var sink = new FileSink(path, new JsonFormatter(), null))
                {
                    sink.Emit(evt);
                }

                var lines = System.IO.File.ReadAllLines(path);
                Assert.Contains("Hello, world!", lines[0]);
                Assert.Contains("Hello, world!", lines[1]);
            }
        }