TelemetryExceptionData tests (Azure#27221)

* TelemetryExceptionData tests

* avoid net461 and netcore differences

* add comments

* add clarification

* resolve pr comments

Author: vishweshbankwar

sdk/monitor/Azure.Monitor.OpenTelemetry.Exporter/src/TelemetryExceptionData.cs

@@ -44,7 +44,7 @@ public TelemetryExceptionData(int version, LogRecord logRecord) : base(version)
                     exceptions.Count - MaxExceptionCountToSave);
 
                 // we'll add our new exception and parent it to the root exception (first one in the list)
-                exceptions.Add(new TelemetryExceptionDetails(countExceededException, null, exceptions[0]));
+                exceptions.Add(new TelemetryExceptionDetails(countExceededException, countExceededException.Message, exceptions[0]));
             }
 
             Exceptions = exceptions;

sdk/monitor/Azure.Monitor.OpenTelemetry.Exporter/tests/Azure.Monitor.OpenTelemetry.Exporter.Tests/TelemetryExceptionDataTests.cs

@@ -2,11 +2,16 @@
 // Licensed under the MIT License.
 
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
+using System.Globalization;
+using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
 using Azure.Monitor.OpenTelemetry.Exporter.Models;
+using Microsoft.Extensions.Logging;
 using Moq;
+using OpenTelemetry.Logs;
 using Xunit;
 
 namespace Azure.Monitor.OpenTelemetry.Exporter.Tests
@@ -104,8 +109,18 @@ public void CheckThatFileNameAndLineAreCorrectIfAvailable()
             var exceptionDetails = new TelemetryExceptionDetails(exception, exception.Message, null);
             var stack = exceptionDetails.ParsedStack;
 
-            Assert.Equal(line, stack[0].Line);
-            Assert.Equal(fileName, stack[0].FileName);
+            // Behavior may vary in some cases and line may return 0
+            // In this case Line will be null
+            if (line != 0)
+            {
+                Assert.Equal(line, stack[0].Line);
+                Assert.Equal(fileName, stack[0].FileName);
+            }
+            else
+            {
+                Assert.Null(stack[0].Line);
+                Assert.Null(stack[0].FileName);
+            }
         }
 
         [Fact]
@@ -149,7 +164,7 @@ public void SizeOfParsedStackFrameIsLessThanMaxAllowedValue()
         }
 
         [Fact]
-        public void ParentIdISetAsOuterId()
+        public void ParentIdIsSetAsOuterId()
         {
             var parentException = new Exception("Parent Exception");
             var parentExceptionDetails = new TelemetryExceptionDetails(parentException, parentException.Message, null);
@@ -159,6 +174,147 @@ public void ParentIdISetAsOuterId()
             Assert.Equal(parentExceptionDetails.Id, exceptionDetails.OuterId);
         }
 
+        [Fact]
+        public void ExceptionDataContainsExceptionDetails()
+        {
+            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>();
+
+            var exception = CreateException(1);
+            logger.LogWarning(exception, exception.Message);
+
+            var exceptionData = new TelemetryExceptionData(2, logRecords[0]);
+
+            Assert.Equal(1, exceptionData.Exceptions.Count);
+        }
+
+        [Fact]
+        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);
+        }
+
+        [Fact]
+        public void ExceptionDataContainsExceptionDetailsWithAllInnerExceptions()
+        {
+            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>();
+
+            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);
+        }
+
+        [Fact]
+        public void AggregateExceptionsWithMultipleNestedExceptionsAreTrimmedAfterReachingMaxCount()
+        {
+            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>();
+
+            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);
+        }
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         private Exception CreateException(int stackDepth)
         {