public void CanCallEndBatchWithoutStartBatch()
{
BatchLogger.EndBatch();
UT.Assert.AreEqual(0, _loggedRecords);
UT.Assert.AreEqual(0, _callsToFallback);
_mockLogger.Verify();
}
public void LogAllThenLogSome()
{
FulcrumApplication.Setup.LogSeverityLevelThreshold = LogSeverityLevel.Warning;
BatchLogger.StartBatch(LogSeverityLevel.Error, false);
Log.LogVerbose("Verbose");
Log.LogInformation("Information");
Log.LogWarning("Warning");
UT.Assert.AreEqual(0, _loggedRecords);
Log.LogError("Error");
UT.Assert.AreEqual(4, _loggedRecords);
Log.LogVerbose("Verbose");
UT.Assert.AreEqual(5, _loggedRecords);
BatchLogger.EndBatch();
_loggedRecords = 0;
BatchLogger.StartBatch(LogSeverityLevel.Error, false);
Log.LogVerbose("Verbose");
Log.LogInformation("Information");
Log.LogWarning("Warning");
UT.Assert.AreEqual(0, _loggedRecords);
BatchLogger.EndBatch();
UT.Assert.AreEqual(1, _loggedRecords);
UT.Assert.AreEqual(0, _callsToFallback);
_mockLogger.Verify();
}
private static void LogProperties(BatchLogger logger, string heading, IVsProjectProperties projectProperties)
{
IEnumerable <string> properties = projectProperties.Cast <ProjectProperty>()
.Select(prop => $"{prop.Name}:{prop.Value}");
logger.WriteLine($"{heading} -- ({string.Join(" | ", properties)})");
}
public void HandlesUnderlyingCollectionProperly()
{
FulcrumApplication.Setup.LogSeverityLevelThreshold = LogSeverityLevel.Warning;
BatchLogger.StartBatch(LogSeverityLevel.Warning, true);
for (var i = 1; i <= 10; i++)
{
Log.LogWarning($"Warning A {i}");
}
var allDone = new ManualResetEvent(false);
// Try to provoke "System.InvalidOperationException: Collection was modified; enumeration operation may not execute."
// Prior to version 4.15.3 this would trigger the exception:
ThreadHelper.FireAndForget(() =>
{
for (var i = 1; i <= 100000; i++)
{
Log.LogWarning($"Warning B {i}");
}
allDone.Set();
});
BatchLogger.EndBatch();
UT.Assert.IsTrue(allDone.WaitOne(TimeSpan.FromSeconds(10)));
UT.Assert.AreEqual(0, _callsToFallback, $"{nameof(_loggedRecords)}: {_loggedRecords}");
UT.Assert.IsTrue(_loggedRecords >= 100, _loggedRecords.ToString());
}
public void BeginBatch_SetIndentLevelToLessThanZero_ThrowsArgumentOutOfRange(int indentLevel)
{
var logger = new MockOutputService();
var batch = new BatchLogger(logger);
Assert.Throws <ArgumentOutOfRangeException>("value", () =>
{
batch.IndentLevel = indentLevel;
});
}
public static void EndNominateRestore(IProjectDiagnosticOutputService logger, string fullPath)
{
if (logger.IsEnabled)
{
using var batch = new BatchLogger(logger);
batch.WriteLine();
batch.WriteLine("------------------------------------------");
batch.WriteLine($"COMPLETED Nominate Restore for {fullPath}");
batch.WriteLine();
}
}
public void BeginBatch_IsEnabled_ReturnsLoggerIsEnabled(bool isEnabled)
{
var logger = new MockOutputService()
{
IsEnabled = isEnabled
};
var batch = new BatchLogger(logger);
Assert.Equal(batch.IsEnabled, logger.IsEnabled);
}
private static void LogTargetFrameworks(BatchLogger logger, IVsTargetFrameworks2 targetFrameworks)
{
logger.WriteLine($"Target Frameworks ({targetFrameworks.Count})");
logger.IndentLevel++;
foreach (IVsTargetFrameworkInfo2 tf in targetFrameworks)
{
LogTargetFramework(logger, tf);
}
logger.IndentLevel--;
}
public void BeginBatch_IndentLevel_AppendsIndentToWriteLine(int indentLevel, string expected)
{
var logger = new MockOutputService();
using (var batch = new BatchLogger(logger))
{
batch.IndentLevel = indentLevel;
batch.WriteLine(string.Empty);
}
Assert.Equal(expected, logger.Text);
}
private static void LogTargetFramework(BatchLogger logger, IVsTargetFrameworkInfo2 targetFrameworkInfo)
{
logger.WriteLine(targetFrameworkInfo.TargetFrameworkMoniker);
logger.IndentLevel++;
LogReferenceItems(logger, "Framework References", targetFrameworkInfo.FrameworkReferences);
LogReferenceItems(logger, "Package Downloads", targetFrameworkInfo.PackageDownloads);
LogReferenceItems(logger, "Project References", targetFrameworkInfo.ProjectReferences);
LogReferenceItems(logger, "Package References", targetFrameworkInfo.PackageReferences);
LogProperties(logger, "Target Framework Properties", targetFrameworkInfo.Properties);
logger.IndentLevel--;
}
public void BeginBatch_WhenUnderlyingLoggerIsNotEnabled_DoesNotLog()
{
var logger = new MockOutputService()
{
IsEnabled = false
};
using (var batch = new BatchLogger(logger))
{
batch.WriteLine("Hello World!");
}
Assert.Null(logger.Text);
}
public void BeginBatch_WhenUnderlyingLoggerIsEnabled_Logs()
{
var logger = new MockOutputService()
{
IsEnabled = true
};
using (var batch = new BatchLogger(logger))
{
batch.WriteLine("Hello World!");
}
Assert.Equal("Hello World!", logger.Text);
}
private static void LogReferenceItems(BatchLogger logger, string heading, IVsReferenceItems references)
{
logger.WriteLine(heading);
logger.IndentLevel++;
foreach (IVsReferenceItem reference in references)
{
IEnumerable <string> properties = reference.Properties.Cast <IVsReferenceProperty>()
.Select(prop => $"{prop.Name}:{prop.Value}");
logger.WriteLine($"{reference.Name} -- ({string.Join(" | ", properties)})");
}
logger.IndentLevel--;
}
public void LogOnlyOverThreshold()
{
FulcrumApplication.Setup.LogSeverityLevelThreshold = LogSeverityLevel.Warning;
BatchLogger.StartBatch(LogSeverityLevel.None, true);
Log.LogVerbose("Verbose");
Log.LogInformation("Information");
Log.LogWarning("Warning");
Log.LogError("Error");
Log.LogCritical("Critical");
UT.Assert.AreEqual(0, _loggedRecords);
BatchLogger.EndBatch();
UT.Assert.AreEqual(3, _loggedRecords);
UT.Assert.AreEqual(0, _callsToFallback);
_mockLogger.Verify();
}
public static void BeginNominateRestore(IProjectDiagnosticOutputService logger, string fullPath, IVsProjectRestoreInfo2 projectRestoreInfo)
{
if (logger.IsEnabled)
{
using var batch = new BatchLogger(logger);
batch.WriteLine();
batch.WriteLine("------------------------------------------");
batch.WriteLine($"BEGIN Nominate Restore for {fullPath}");
batch.IndentLevel++;
batch.WriteLine($"MSBuildProjectExtensionsPath: {projectRestoreInfo.BaseIntermediatePath}");
batch.WriteLine($"OriginalTargetFrameworks: {projectRestoreInfo.OriginalTargetFrameworks}");
LogTargetFrameworks(batch, projectRestoreInfo.TargetFrameworks);
LogReferenceItems(batch, "Tool References", projectRestoreInfo.ToolReferences);
batch.IndentLevel--;
batch.WriteLine();
}
}
public void BeginBatch_CanLogMultipleWriteLines()
{
var logger = new MockOutputService()
{
IsEnabled = true
};
using (var batch = new BatchLogger(logger))
{
batch.WriteLine("Line1");
batch.IndentLevel = 1;
batch.WriteLine("Line2");
batch.IndentLevel = 0;
batch.WriteLine("Line3");
}
// NOTE: No trailing new line, as the logger itself should be adding it
Assert.Equal("Line1\r\n Line2\r\nLine3", logger.Text, ignoreLineEndingDifferences: true);
}
static void Main(string[] args)
{
var writer = new ConsoleWriter();
var logger = new Logger(writer);
logger.Debug("First debug message");
logger.Error("First error message");
logger.Fatal("First fatal message");
logger.Info("First info message");
var writers = new WriterPool(new List <IWriter> {
new ConsoleWriter()
});
var batchLogger = new BatchLogger(writers);
Console.WriteLine();
batchLogger.Debug("Batch debug");
batchLogger.Error("Batch error");
Console.WriteLine("Let's FLUSH ))");
batchLogger.Flush();
Console.ReadLine();
}
// TODO: Make code example complete
// TODO: Make callbacks in options
// TODO: Move code into one big invoke
// ReSharper disable once UnusedMember.Global
/// <summary>
/// The main method for a middleware.
/// </summary>
/// <param name="context">The information about the current HTTP request.</param>
public virtual async Task InvokeAsync(HttpContext context)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
var cancellationToken = context.RequestAborted;
// Enable multiple reads of the content
context.Request.EnableBuffering();
try
{
if (Options.Features.SaveClientTenant.Enabled)
{
var tenant = GetClientTenantFromUrl(context);
FulcrumApplication.Context.ClientTenant = tenant;
}
if (Options.Features.SaveCorrelationId.Enabled)
{
var correlationId = GetOrCreateCorrelationId(context);
FulcrumApplication.Context.CorrelationId = correlationId;
}
if (Options.Features.SaveExecutionId.Enabled)
{
var parentExecutionId = ExtractParentExecutionIdFromHeader(context);
FulcrumApplication.Context.ParentExecutionId = parentExecutionId;
var executionId = ExtractExecutionIdFromHeader(context);
FulcrumApplication.Context.ExecutionId = executionId;
}
if (Options.Features.SaveTenantConfiguration.Enabled)
{
var tenantConfiguration = await GetTenantConfigurationAsync(FulcrumApplication.Context.ClientTenant, context, cancellationToken);
FulcrumApplication.Context.LeverConfiguration = tenantConfiguration;
}
if (Options.Features.SaveNexusTestContext.Enabled)
{
var testContext = GetNexusTestContextFromHeader(context);
FulcrumApplication.Context.NexusTestContext = testContext;
}
if (Options.Features.BatchLog.Enabled)
{
BatchLogger.StartBatch(Options.Features.BatchLog.Threshold, Options.Features.BatchLog.FlushAsLateAsPossible);
}
try
{
await Next(context);
if (Options.Features.LogRequestAndResponse.Enabled)
{
await LogResponseAsync(context, stopwatch.Elapsed, cancellationToken);
}
}
catch (Exception exception)
{
var shouldThrow = true;
if (Options.Features.ConvertExceptionToHttpResponse.Enabled)
{
await ConvertExceptionToResponseAsync(context, exception, cancellationToken);
shouldThrow = false;
if (Options.Features.LogRequestAndResponse.Enabled)
{
await LogResponseAsync(context, stopwatch.Elapsed, cancellationToken);
}
}
if (shouldThrow)
{
throw;
}
}
}
catch (Exception exception)
{
if (Options.Features.LogRequestAndResponse.Enabled)
{
LogException(context, exception, stopwatch.Elapsed);
}
throw;
}
finally
{
if (Options.Features.BatchLog.Enabled)
{
BatchLogger.EndBatch();
}
}
}
