public void ValidateTelemetryExceptionData(LogLevel logLevel)
{
var logRecords = new List <LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.AddFilter(typeof(TelemetryExceptionDataTests).FullName, LogLevel.Trace);
});
var logger = loggerFactory.CreateLogger <TelemetryExceptionDataTests>();
var ex = new Exception("Message");
logger.Log(logLevel, ex, "Message");
var exceptionData = new TelemetryExceptionData(2, logRecords[0]);
Assert.Equal(2, exceptionData.Version);
Assert.Equal(LogsHelper.GetSeverityLevel(logLevel), exceptionData.SeverityLevel);
Assert.Empty(exceptionData.Properties);
Assert.Empty(exceptionData.Measurements);
Assert.Equal(typeof(Exception).FullName + " at UnknownMethod", exceptionData.ProblemId);
Assert.Equal(1, exceptionData.Exceptions.Count);
Assert.Equal("Message", exceptionData.Exceptions[0].Message);
Assert.Null(exceptionData.Exceptions[0].Stack);
Assert.Equal(ex.GetHashCode(), exceptionData.Exceptions[0].Id);
Assert.Empty(exceptionData.Exceptions[0].ParsedStack);
Assert.True(exceptionData.Exceptions[0].HasFullStack);
}
public void ExceptionDataContainsExceptionDetailsWithAllInnerExceptions()
{
var logRecords = new List <LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.AddFilter(typeof(TelemetryExceptionDataTests).FullName, LogLevel.Trace);
});
var logger = loggerFactory.CreateLogger <TelemetryExceptionDataTests>();
var innerException1 = new Exception("Inner1");
var innerexception2 = new Exception("Inner2", innerException1);
var exception = new Exception("Exception", innerexception2);
// Passing "Exception" explicitly here instead of using exception.Message
// exception.Message will return different value in case of net461 compared to netcore
logger.LogWarning(exception, "Exception");
var exceptionData = new TelemetryExceptionData(2, logRecords[0]);
Assert.Equal(3, exceptionData.Exceptions.Count);
Assert.Equal("Exception", exceptionData.Exceptions[0].Message);
Assert.Equal("Inner2", exceptionData.Exceptions[1].Message);
Assert.Equal("Inner1", exceptionData.Exceptions[2].Message);
}
public void ExceptionDataContainsExceptionDetailsofAllInnerExceptionsOfAggregateException()
{
var logRecords = new List <LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.AddFilter(typeof(LogsHelperTests).FullName, LogLevel.Trace);
});
var logger = loggerFactory.CreateLogger <LogsHelperTests>();
Exception innerException1 = new ArgumentException("Inner1");
Exception innerException2 = new ArgumentException("Inner2");
AggregateException aggregateException = new AggregateException("AggregateException", new[] { innerException1, innerException2 });
// Passing "AggregateException" explicitly here instead of using aggregateException.Message
// aggregateException.Message will return different value in case of net461 compared to netcore
logger.LogWarning(aggregateException, "AggregateException");
var exceptionData = new TelemetryExceptionData(2, logRecords[0]);
Assert.Equal(3, exceptionData.Exceptions.Count);
Assert.Equal("AggregateException", exceptionData.Exceptions[0].Message);
Assert.Equal("Inner1", exceptionData.Exceptions[1].Message);
Assert.Equal("Inner2", exceptionData.Exceptions[2].Message);
}
public void AggregateExceptionsWithMultipleNestedExceptionsAreTrimmedAfterReachingMaxCount()
{
var logRecords = new List <LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.AddFilter(typeof(TelemetryExceptionDataTests).FullName, LogLevel.Trace);
});
var logger = loggerFactory.CreateLogger <TelemetryExceptionDataTests>();
int numberOfExceptions = 15;
int maxNumberOfExceptionsAllowed = 10;
List <Exception> innerExceptions = new List <Exception>();
for (int i = 0; i < numberOfExceptions; i++)
{
innerExceptions.Add(new Exception((i + 1).ToString(CultureInfo.InvariantCulture)));
}
AggregateException rootLevelException = new AggregateException("0", innerExceptions);
// Passing "0" explicitly here instead of using rootLevelException.Message
// rootLevelException.Message will return different value in case of net461 compared to netcore
logger.LogWarning(rootLevelException, "0");
var exceptionData = new TelemetryExceptionData(2, logRecords[0]);
Assert.Equal(maxNumberOfExceptionsAllowed + 1, exceptionData.Exceptions.Count);
for (int counter = 0; counter < maxNumberOfExceptionsAllowed; counter++)
{
var details = exceptionData.Exceptions[counter];
Assert.Equal(counter.ToString(CultureInfo.InvariantCulture), details.Message);
}
var firstExceptionInList = exceptionData.Exceptions.First();
var lastExceptionInList = exceptionData.Exceptions.Last();
Assert.Equal(firstExceptionInList.Id, lastExceptionInList.OuterId);
Assert.Equal(typeof(InnerExceptionCountExceededException).FullName, lastExceptionInList.TypeName);
Assert.Equal(
string.Format(
CultureInfo.InvariantCulture,
"The number of inner exceptions was {0} which is larger than {1}, the maximum number allowed during transmission. All but the first {1} have been dropped.",
numberOfExceptions + 1,
maxNumberOfExceptionsAllowed),
lastExceptionInList.Message);
}
public void ExceptionDataContainsExceptionDetails()
{
var logRecords = new List <LogRecord>();
using var loggerFactory = LoggerFactory.Create(builder =>
{
builder.AddOpenTelemetry(options =>
{
options.AddInMemoryExporter(logRecords);
});
builder.AddFilter(typeof(TelemetryExceptionDataTests).FullName, LogLevel.Trace);
});
var logger = loggerFactory.CreateLogger <TelemetryExceptionDataTests>();
var exception = CreateException(1);
logger.LogWarning(exception, exception.Message);
var exceptionData = new TelemetryExceptionData(2, logRecords[0]);
Assert.Equal(1, exceptionData.Exceptions.Count);
}
