public static void Constructor___Valid___Works()
{
// Arrange
var configurations = new LogWriterConfigBase[] { ShareSerializationTestLogic.FileConfig, ShareSerializationTestLogic.EventLogConfig, ShareSerializationTestLogic.ConsoleConfig }.ToList();
// Act
var actual = new LogWritingSettings(configurations);
// Assert
actual.Should().NotBeNull();
actual.Configs.Should().BeEquivalentTo(configurations);
}
public static void Constructor___Null_configuration___Empty_set()
{
// Arrange
LogWriterConfigBase[] configurations = null;
// Act
var actual = new LogWritingSettings(configurations);
// Assert
actual.Should().NotBeNull();
actual.Configs.Should().NotBeNull();
actual.Configs.Should().BeEmpty();
}
/// <summary>
/// Runs common setup logic to prepare for and <see cref="Naos.Configuration" />, also will launch the debugger if the debug flag is provided.
/// </summary>
/// <param name="debug">A value indicating whether or not to launch the debugger.</param>
/// <param name="environment">Optional environment name that will set the <see cref="Naos.Configuration" /> precedence instead of the default which is reading the App.Config value.</param>
/// <param name="logWritingSettings">Optional <see cref="LogWritingSettings" /> to use instead of the default found in <see cref="Naos.Configuration" />.</param>
/// <param name="configuredAndManagedLogProcessors">Optional set of pre-configured and externally managed <see cref="LogWriterBase" /> to use.</param>
/// <param name="announcer">Optional announcer; DEFAULT is null which will go to <see cref="Console.WriteLine(string)" />.<see cref="Console.WriteLine(string)" />.</param>
protected static void CommonSetup(bool debug, string environment = null, LogWritingSettings logWritingSettings = null, IReadOnlyCollection <LogWriterBase> configuredAndManagedLogProcessors = null, Action <string> announcer = null)
{
var launchTime = DateTime.UtcNow;
var localAnnouncer = BuildPrefixingAnnouncer(announcer);
localAnnouncer(Invariant($"Launched at {launchTime.ToLocalTime().TimeOfDay} on {launchTime.ToLocalTime().Date} (Local) | {launchTime.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture)}Z (UTC)."));
localAnnouncer(Invariant($"> Common Setup"));
/*---------------------------------------------------------------------------*
* Useful for launching the debugger from the command line and making sure *
* it is connected to the instance of the IDE you want to use. *
*---------------------------------------------------------------------------*/
if (debug)
{
localAnnouncer(Invariant($"Debugger was set to be launched (debug=true option provide).{Environment.NewLine}{DefaultAnnouncementPadding}{DefaultAnnouncementPadding}- If the VisualStudio debugger menu is not shown check your 'Just-In-Time debugger' settings.{Environment.NewLine}{DefaultAnnouncementPadding}{DefaultAnnouncementPadding}- Go to (Visual Studio Menu Bar)->Tools->Options{Environment.NewLine}{DefaultAnnouncementPadding}{DefaultAnnouncementPadding}- then (Options Left Pane Navigation)->Debugging->Just-In-Time{Environment.NewLine}{DefaultAnnouncementPadding}{DefaultAnnouncementPadding}- then (Just-In-Time Debugging Settings on right pane)->Make sure the 'Managed' check box is checked."));
Debugger.Launch();
}
/*---------------------------------------------------------------------------*
* Setup deserialization logic for any use of Naos.Configuration reading *
* config files from the '.config' directory with 'environment' sub folders *
* the chain of responsibility is set in the App.config file using the *
* 'Naos.Configuration.Settings.Precedence' setting. You can override the *
* way this is used by specifying a different directory for the config or *
* providing additional precedence values using *
* ResetConfigureSerializationAndSetValues. *
*---------------------------------------------------------------------------*/
if (!string.IsNullOrWhiteSpace(environment))
{
localAnnouncer(Invariant($"Set Config Precedence to: '{environment}'."));
Config.SetPrecedence(environment, Config.CommonPrecedence);
}
/*---------------------------------------------------------------------------*
* Initialize logging; this sets up Its.Log which is what gets used through- *
* out the code. All logging will also get sent through it. This can be *
* swapped out to send all Its.Log messages to another logging framework if *
* there is already one in place. *
*---------------------------------------------------------------------------*/
var localLogProcessorSettings = logWritingSettings ?? Config.Get <LogWritingSettings>(new SerializerRepresentation(SerializationKind.Json, typeof(LoggingJsonSerializationConfiguration).ToRepresentation()));
if (localLogProcessorSettings == null)
{
localAnnouncer(Invariant($"{DefaultAnnouncementPadding}- No LogProcessorSettings provided or found in config; using Null Object substitute."));
localLogProcessorSettings = new LogWritingSettings();
}
LogWriting.Instance.Setup(localLogProcessorSettings, localAnnouncer, configuredAndManagedLogProcessors, errorCodeKeys: new[] { "__OBC_ErrorCode__" });
localAnnouncer(Invariant($"< Common Setup"));
}
/// <summary>
/// Runs common setup logic to prepare for and <see cref="Naos.Configuration" />, also will launch the debugger if the debug flag is provided.
/// </summary>
/// <param name="debug">A value indicating whether or not to launch the debugger.</param>
/// <param name="environment">Optional environment name that will set the <see cref="Naos.Configuration" /> precedence instead of the default which is reading the App.Config value.</param>
/// <param name="logWritingSettings">Optional <see cref="LogWritingSettings" /> to use instead of the default found in <see cref="Naos.Configuration" />.</param>
/// <param name="configuredAndManagedLogProcessors">Optional set of pre-configured and externally managed <see cref="LogWriterBase" /> to use.</param>
/// <param name="announcer">Optional announcer; DEFAULT is null which will go to <see cref="Console.WriteLine(string)" />.<see cref="Console.WriteLine(string)" />.</param>
protected static void CommonSetup(bool debug, string environment = null, LogWritingSettings logWritingSettings = null, IReadOnlyCollection <LogWriterBase> configuredAndManagedLogProcessors = null, Action <string> announcer = null)
{
var localAnnouncer = announcer ?? Console.WriteLine;
/*---------------------------------------------------------------------------*
* Useful for launching the debugger from the command line and making sure *
* it is connected to the instance of the IDE you want to use. *
*---------------------------------------------------------------------------*/
if (debug)
{
Debugger.Launch();
}
/*---------------------------------------------------------------------------*
* Setup deserialization logic for any use of Naos.Configuration reading *
* config files from the '.config' directory with 'environment' sub folders *
* the chain of responsibility is set in the App.config file using the *
* 'Naos.Configuration.Settings.Precedence' setting. You can override the *
* way this is used by specifying a different diretory for the config or *
* providing additonal precedence values using *
* ResetConfigureSerializationAndSetValues. *
*---------------------------------------------------------------------------*/
if (!string.IsNullOrWhiteSpace(environment))
{
Config.SetPrecedence(environment, Config.CommonPrecedence);
}
/*---------------------------------------------------------------------------*
* Initialize logging; this sets up Its.Log which is what gets used through- *
* out the code. All logging will also get sent through it. This can be *
* swapped out to send all Its.Log messages to another logging framework if *
* there is already one in place. *
*---------------------------------------------------------------------------*/
var localLogProcessorSettings = logWritingSettings ?? Config.Get <LogWritingSettings>(typeof(LoggingJsonConfiguration));
if (localLogProcessorSettings == null)
{
localAnnouncer("No LogProcessorSettings provided or found in config; using Null Object susbstitue.");
localLogProcessorSettings = new LogWritingSettings();
}
LogWriting.Instance.Setup(localLogProcessorSettings, localAnnouncer, configuredAndManagedLogProcessors, errorCodeKeys: new[] { "__OBC_ErrorCode__" });
}
public static void Example(
[Aliases("")][Description("Launches the debugger.")][DefaultValue(false)] bool debug,
[Aliases("")][Description("Sets the Naos.Configuration precedence to use specific settings.")][DefaultValue(null)] string environment,
[Required][Aliases("")][Description("Example of a directory that needs to be checked for files to process.")] string filePathToProcess)
{
/*---------------------------------------------------------------------------*
* Normally this would just be done from the Naos.Configuration file but the *
* we're overriding to only use the Console for demonstration purposes. *
*---------------------------------------------------------------------------*/
var logProcessorSettingsOverride = new LogWritingSettings(new[]
{
new ConsoleLogConfig(
new Dictionary <LogItemKind, IReadOnlyCollection <string> >(), // all
new Dictionary <LogItemKind, IReadOnlyCollection <string> > {
{ LogItemKind.Exception, null }
}, // all Exceptions
new Dictionary <LogItemKind, IReadOnlyCollection <string> > // Strings and Objects from ItsLogEntryPosted
{
{ LogItemKind.String, new[] { LogItemOrigin.ItsLogEntryPosted.ToString() } },
{ LogItemKind.Object, new[] { LogItemOrigin.ItsLogEntryPosted.ToString() } },
}),
});
/*---------------------------------------------------------------------------*
* Any method should run this logic to debug, setup config & logging, etc. *
*---------------------------------------------------------------------------*/
CommonSetup(debug, environment, logProcessorSettingsOverride);
/*---------------------------------------------------------------------------*
* Any method should run this logic to write telemetry info to the log. *
*---------------------------------------------------------------------------*/
// WriteStandardTelemetry(); // removing this for now because it's not being collected well enough
/*---------------------------------------------------------------------------*
* This is not necessary but often very useful to print out the arguments. *
*---------------------------------------------------------------------------*/
PrintArguments(new { filePathToProcess, environment });
Its.Log.Instrumentation.Log.Write(() => Invariant($"Processed files at: {filePathToProcess}"));
}
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);
}
}
public void Setup(
LogWritingSettings logWritingSettings,
Action <string> announcer = null,
IReadOnlyCollection <LogWriterBase> configuredAndManagedLogWriters = null,
MultipleCallsToSetupStrategy multipleCallsToSetupStrategy = MultipleCallsToSetupStrategy.Throw,
IReadOnlyCollection <string> errorCodeKeys = null)
{
if (logWritingSettings == null)
{
throw new ArgumentNullException(nameof(logWritingSettings));
}
if (multipleCallsToSetupStrategy == MultipleCallsToSetupStrategy.Invalid)
{
throw new ArgumentException(Invariant($"{nameof(multipleCallsToSetupStrategy)} == {nameof(MultipleCallsToSetupStrategy.Invalid)}"));
}
this.errorCodeKeysField = errorCodeKeys;
var localAnnouncer = announcer ?? NullAnnouncement;
lock (this.sync)
{
if (this.hasBeenSetup)
{
switch (multipleCallsToSetupStrategy)
{
case MultipleCallsToSetupStrategy.Throw:
throw new ArgumentException(Invariant($"{nameof(LogWriting)}.{nameof(LogWriting.Setup)} was called a second time with {nameof(multipleCallsToSetupStrategy)} - {multipleCallsToSetupStrategy}."));
case MultipleCallsToSetupStrategy.Ignore:
return;
case MultipleCallsToSetupStrategy.Overwrite:
break;
default:
throw new NotSupportedException(Invariant($"{nameof(LogWriting)}.{nameof(LogWriting.Setup)} was called with unspported {nameof(multipleCallsToSetupStrategy)} - {multipleCallsToSetupStrategy}."));
}
}
this.hasBeenSetup = true;
var logWriters = new List <LogWriterBase>(configuredAndManagedLogWriters ?? new LogWriterBase[0]);
if (logWriters.Any())
{
localAnnouncer(Invariant($"Used pre-configured loggers: {string.Join(",", logWriters)}"));
}
foreach (var config in logWritingSettings.Configs)
{
LogWriterBase logWriter;
switch (config)
{
case FileLogConfig fileLogConfig:
logWriter = new FileLogWriter(fileLogConfig);
break;
case TimeSlicedFilesLogConfig timeSlicedFilesLogConfig:
logWriter = new TimeSlicedFilesLogWriter(timeSlicedFilesLogConfig);
break;
case EventLogConfig eventLogConfig:
logWriter = new EventLogWriter(eventLogConfig);
break;
case ConsoleLogConfig consoleLogConfig:
logWriter = new ConsoleLogWriter(consoleLogConfig);
break;
default:
throw new NotSupportedException(Invariant($"Unsupported implementation of {nameof(LogWriterConfigBase)} - {config.GetType().ToStringReadable()}, try providing a pre-configured implementation of {nameof(LogWriterBase)} until the config type is supported."));
}
logWriters.Add(logWriter);
localAnnouncer(Invariant($"Wired up {logWriter}."));
}
this.activeLogWriters = logWriters;
this.WireUpAppDomainUnhandledExceptionToActiveLogWriters(localAnnouncer);
this.WireUpItsLogInternalErrorsToActiveLogWriters(localAnnouncer);
this.WireUpItsLogEntryPostedToActiveLogWriters(localAnnouncer);
this.WireUpNaosLoggerToActiveLogWriters(localAnnouncer);
}
}
