public static void LogProcessor___Default_max_elements___Honored()
        {
            // Arrange
            var configuration = new InMemoryLogConfig(LogInclusionKindToOriginsMaps.AnythingFromAnywhere);
            var processor     = new InMemoryLogWriter(configuration);
            var logCallCount  = 1000;

            // Act
            Enumerable.Range(0, logCallCount).ToList().ForEach(_ => processor.Log("Hello".ToLogEntry().ToLogItem(LogItemOrigin.ItsLogEntryPosted)));

            // Assert
            processor.LoggedItems.Count.Should().Be(logCallCount);
        }
        public static void LogProcessor___Purge___Works()
        {
            // Arrange
            var configuration = new InMemoryLogConfig(LogInclusionKindToOriginsMaps.AnythingFromAnywhere);
            var processor     = new InMemoryLogWriter(configuration);
            var logCallCount  = 10;

            Enumerable.Range(0, logCallCount).ToList().ForEach(_ => processor.Log("Hello".ToLogEntry().ToLogItem(LogItemOrigin.ItsLogEntryPosted)));

            // Act
            processor.PurgeAllLoggedItems();

            // Assert
            processor.LoggedItems.Count.Should().Be(0);
        }
        public static void LogProcessor___Valid___Works()
        {
            // Arrange
            var configuration = new InMemoryLogConfig(LogInclusionKindToOriginsMaps.AnythingFromAnywhere);
            var processor     = new InMemoryLogWriter(configuration);

            var infoCanary  = A.Dummy <string>();
            var errorCanary = new ArgumentException(A.Dummy <string>());

            // Act
            processor.Log(infoCanary.ToLogEntry().ToLogItem(LogItemOrigin.ItsLogEntryPosted));
            processor.Log(errorCanary.ToLogEntry().ToLogItem(LogItemOrigin.ItsLogEntryPosted));

            // Assert
            processor.LoggedItems.Count.Should().Be(2);
            processor.LoggedItems.Single(_ => _.Context.Origin == LogItemOrigin.ItsLogEntryPosted.ToString() && _.Kind == LogItemKind.String).Subject.Summary.Should().Contain(infoCanary);
            processor.LoggedItems.Single(_ => _.Context.Origin == LogItemOrigin.ItsLogEntryPosted.ToString() && _.Kind == LogItemKind.Exception).Subject.Summary.Should().Contain(errorCanary.Message);
        }
Example #4
0
        private static InMemoryLogWriter BuildAndConfigureMemoryLogWriter()
        {
            lock (MemoryLogWriterSync)
            {
                if (memoryLogWriter == null)
                {
                    var memoryLogConfig =
                        new InMemoryLogConfig(new Dictionary <LogItemKind, IReadOnlyCollection <string> >());
                    memoryLogWriter = new InMemoryLogWriter(memoryLogConfig);
                    var settings = new LogWritingSettings();
                    LogWriting.Instance.Setup(
                        settings,
                        configuredAndManagedLogWriters: new[] { memoryLogWriter },
                        errorCodeKeys: new[] { ErrorCodeConstants.ExceptionDataKeyForErrorCode },
                        multipleCallsToSetupStrategy: MultipleCallsToSetupStrategy.Overwrite);
                }
                else
                {
                    memoryLogWriter.PurgeAllLoggedItems();
                }

                return(memoryLogWriter);
            }
        }
        public void Test_NaosLogWrite_Versus_ItsLogWrite()
        {
            // Arrange
            var memoryLogConfig =
                new InMemoryLogConfig(new Dictionary <LogItemKind, IReadOnlyCollection <string> >());
            var memoryLogWriter = new InMemoryLogWriter(memoryLogConfig);
            var settings        = new LogWritingSettings();

            LogWriting.Instance.Setup(
                settings,
                configuredAndManagedLogWriters: new[] { memoryLogWriter },
                errorCodeKeys: new[] { ErrorCodeConstants.ExceptionDataKeyForErrorCode },
                multipleCallsToSetupStrategy: MultipleCallsToSetupStrategy.Overwrite);

            var itsLogStopwatch  = new Stopwatch();
            var naosLogStopwatch = new Stopwatch();
            var testSubjects     = Enumerable.Range(0, 100).Select(_ => Invariant($"{Guid.NewGuid().ToString()}{_}")).ToList();

            // Act
            itsLogStopwatch.Start();
            foreach (var testSubject in testSubjects)
            {
                Its.Log.Instrumentation.Log.Write(() => testSubject);
                using (var logger = Its.Log.Instrumentation.Log.Enter(() => testSubject))
                {
                    logger.Trace(() => testSubject);
                }
            }

            while (memoryLogWriter.LoggedItems.Count < testSubjects.Count * 4)
            {
                Thread.Sleep(100);
            }

            itsLogStopwatch.Stop();
            this.testOutputHelper.WriteLine("Its Log Took: " + itsLogStopwatch.Elapsed);

            memoryLogWriter.PurgeAllLoggedItems();
            naosLogStopwatch.Start();
            foreach (var testSubject in testSubjects)
            {
                Naos.Logging.Domain.Log.Write(() => testSubject);
                using (var logger = Naos.Logging.Domain.Log.With(() => testSubject))
                {
                    logger.Write(() => testSubject);
                }
            }

            while (memoryLogWriter.LoggedItems.Count < testSubjects.Count * 4)
            {
                Thread.Sleep(100);
            }

            naosLogStopwatch.Stop();
            this.testOutputHelper.WriteLine("Naos Log Took: " + naosLogStopwatch.Elapsed);

            naosLogStopwatch.Elapsed.Should().BeLessThan(itsLogStopwatch.Elapsed);

            foreach (var logItem in memoryLogWriter.LoggedItems)
            {
                var message = LogWriterBase.BuildLogMessageFromLogItem(logItem, LogItemPropertiesToIncludeInLogMessage.Default, memoryLogWriter.BuildSerializer());
                this.testOutputHelper.WriteLine(message);
            }
        }