NLogTargetTests.cs

namespace Microsoft.ApplicationInsights.NLogTarget.Tests
{
    using System;
    using System.Diagnostics;
    using System.Linq;

    using Microsoft.ApplicationInsights.CommonTestShared;
    using Microsoft.ApplicationInsights.DataContracts;
    using Microsoft.ApplicationInsights.Extensibility;
    using Microsoft.ApplicationInsights.Extensibility.Implementation;
    using Microsoft.ApplicationInsights.NLogTarget;
    using Microsoft.ApplicationInsights.Tracing.Tests;
    using Microsoft.VisualStudio.TestTools.UnitTesting;

    using NLog;
    using NLog.Config;
    using NLog.Targets;
    using NLog.Targets.Wrappers;

    [TestClass]
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Disposing the object on the TestCleanup method")]
    public class ApplicationInsightsTargetTests
    {
        private AdapterHelper adapterHelper;

        public TestContext TestContext { get; set; }

        [TestInitialize]
        public void Initialize()
        {
            this.adapterHelper = new AdapterHelper();
        }

        [TestCleanup]
        public void Cleanup()
        {
            NLog.GlobalDiagnosticsContext.Clear();
            this.adapterHelper.Dispose();
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void InitializeTargetNotThrowsWhenConnectionStringIsNull()
        {
            try
            {
                this.CreateTargetWithGivenConnectionString(null);
            }
            catch (NLogConfigurationException ex)
            {
                Assert.Fail("Not expecting to get NLogConfigurationException but was thrown {0}", ex.Message);
            }
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void InitializeTargetNotThrowsWhenConnectionStringIsEmptyString()
        {
            try
            {
                this.CreateTargetWithGivenConnectionString(string.Empty);
            }
            catch (NLogConfigurationException ex)
            {
                Assert.Fail("Expected NLogConfigurationException but none was thrown with message:{0}", ex.Message);
            }
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void ExceptionsDoNotEscapeNLog()
        {
            var connectionString = "InstrumentationKey=93d9c2b7-e633-4571-8520-d391511a1df5;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/";

            static void loggerAction(Logger aiLogger) => aiLogger.Trace("Hello World");
            this.CreateTargetWithGivenConnectionString(connectionString, loggerAction);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TracesAreEnqueuedInChannel()
        {
            var connectionString = "InstrumentationKey=93d9c2b7-e633-4571-8520-d391511a1df5;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/";

            var aiLogger = this.CreateTargetWithGivenConnectionString(connectionString);
            this.VerifyMessagesInMockChannel(aiLogger, "93d9c2b7-e633-4571-8520-d391511a1df5");
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void ConnectionStringIsReadFromEnvironment()
        {
            var connectionString = "InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/";

            var aiLogger = this.CreateTargetWithGivenConnectionString(connectionString);
            this.VerifyMessagesInMockChannel(aiLogger, "F8474271-D231-45B6-8DD4-D344C309AE69");
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void ConnectionStringIsReadFromLayout()
        {
            var connectionString = "InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/";

            var gdcKey = Guid.NewGuid().ToString();
            GlobalDiagnosticsContext.Set(gdcKey, connectionString);

            var aiLogger = this.CreateTargetWithGivenConnectionString($"${{gdc:item={gdcKey}}}");
            this.VerifyMessagesInMockChannel(aiLogger, "F8474271-D231-45B6-8DD4-D344C309AE69");
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceAreEnqueuedInChannelAndContainAllProperties()
        {
            var connectionString = "InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/";

#pragma warning disable CA5394 // Do not use insecure randomness - Test message has no security impact
            var random = new Random();
            var number = random.Next();
#pragma warning restore CA5394 // Do not use insecure randomness - Test message has no security impact

            var aiLogger = this.CreateTargetWithGivenConnectionString(connectionString);

            aiLogger.Debug("Message {0}, using instrumentation key:{1}", number, connectionString);

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");

            telemetry.Properties.TryGetValue("LoggerName", out var loggerName);
            Assert.AreEqual("AITarget", loggerName);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void SdkVersionIsCorrect()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            aiLogger.Debug("Message");

            var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();

            var expectedVersion = SdkVersionHelper.GetExpectedSdkVersion(prefix: "nlog:", loggerType: typeof(ApplicationInsightsTarget));
            Assert.AreEqual(expectedVersion, telemetry.Context.GetInternalContext().SdkVersion);
        }

        [TestMethod]
        [Ignore("This test requires a valid connection string or instrumentation key to run")]
        [TestCategory("NLogTarget")]
        public async Task TelemetryIsAcceptedByValidateEndpoint()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            aiLogger.Debug("Message");

            var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();

            Assert.IsNull(await TelemetrySender.ValidateEndpointSend(telemetry).ConfigureAwait(true));
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceHasTimestamp()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            aiLogger.Debug("Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");

            Assert.AreNotEqual(default, telemetry.Timestamp);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceMessageCanBeFormedUsingLayout()
        {
            using ApplicationInsightsTarget target = new();
            target.Layout = @"${uppercase:${level}} ${message}";

            var aiLogger = this.CreateTargetWithGivenConnectionString(target: target);

            aiLogger.Debug("Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");

            Assert.AreEqual("DEBUG Message", telemetry.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceMessageWithoutLayoutDefaultsToMessagePassed()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            aiLogger.Debug("My Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");

            Assert.AreEqual("My Message", telemetry.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceHasSequenceId()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            aiLogger.Debug("Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");

            Assert.AreNotEqual("0", telemetry.Sequence);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceHasCustomProperties()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            var eventInfo = new LogEventInfo(LogLevel.Trace, "TestLogger", "Hello!");
            eventInfo.Properties["Name"] = "Value";
            aiLogger.Log(eventInfo);

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");
            Assert.AreEqual("Value", telemetry.Properties["Name"]);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceHasComplexPropertiesSerializedAsJson()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            var complexObject = new
            {
                Name = "John Doe",
                Age = 30,
                Address = new
                {
                    Street = "123 Main St",
                    City = "New York",
                    ZipCode = "10001"
                },
                Tags = new[] { "tag1", "tag2", "tag3" }
            };

            var eventInfo = new LogEventInfo(LogLevel.Trace, "TestLogger", "Hello!");
            eventInfo.Properties["ComplexObject"] = complexObject;
            eventInfo.Properties["SimpleString"] = "SimpleValue";
            aiLogger.Log(eventInfo);

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");
            
            // Simple string should remain as is
            Assert.AreEqual("SimpleValue", telemetry.Properties["SimpleString"]);
            
            // Complex object should be serialized to JSON
            Assert.IsTrue(telemetry.Properties.ContainsKey("ComplexObject"), "ComplexObject property not found");
            var complexJson = telemetry.Properties["ComplexObject"];
            
            // Verify it's JSON and contains expected properties
            Assert.IsTrue(complexJson.Contains("\"Name\""), "JSON should contain Name property");
            Assert.IsTrue(complexJson.Contains("\"John Doe\""), "JSON should contain Name value");
            Assert.IsTrue(complexJson.Contains("\"Age\""), "JSON should contain Age property");
            Assert.IsTrue(complexJson.Contains("30"), "JSON should contain Age value");
            Assert.IsTrue(complexJson.Contains("\"Address\""), "JSON should contain Address property");
            Assert.IsTrue(complexJson.Contains("\"Street\""), "JSON should contain nested Street property");
            Assert.IsTrue(complexJson.Contains("\"123 Main St\""), "JSON should contain nested Street value");
            Assert.IsTrue(complexJson.Contains("\"Tags\""), "JSON should contain Tags array");
            Assert.IsTrue(complexJson.Contains("\"tag1\""), "JSON should contain array values");
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceHandlesVariousPropertyTypes()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            var eventInfo = new LogEventInfo(LogLevel.Info, "TestLogger", "Testing various types");
            eventInfo.Properties["String"] = "Simple string";
            eventInfo.Properties["Int"] = 42;
            eventInfo.Properties["Bool"] = true;
            eventInfo.Properties["Decimal"] = 3.14m;
            eventInfo.Properties["DateTime"] = new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc);
            eventInfo.Properties["Array"] = new[] { 1, 2, 3 };
            eventInfo.Properties["Dictionary"] = new Dictionary<string, object> { { "key1", "value1" }, { "key2", 123 } };
            eventInfo.Properties["Null"] = null;
            
            aiLogger.Log(eventInfo);

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsNotNull(telemetry, "Didn't get the log event from the channel");
            
            // Simple types should be preserved as strings
            Assert.AreEqual("Simple string", telemetry.Properties["String"]);
            Assert.AreEqual("42", telemetry.Properties["Int"]);
            Assert.AreEqual("True", telemetry.Properties["Bool"]);
            Assert.IsTrue(telemetry.Properties["Decimal"].Contains("3.14"), "Decimal value should contain 3.14");
            
            // Complex types should be serialized to JSON
            Assert.IsTrue(telemetry.Properties["Array"].Contains("["), "Array should be JSON array");
            Assert.IsTrue(telemetry.Properties["Array"].Contains("1"), "Array should contain values");
            Assert.IsTrue(telemetry.Properties["Dictionary"].Contains("key1"), "Dictionary should be serialized");
            Assert.IsTrue(telemetry.Properties["Dictionary"].Contains("value1"), "Dictionary should contain values");
            
            // Null should be empty string
            Assert.AreEqual(string.Empty, telemetry.Properties["Null"]);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void GlobalDiagnosticContextPropertiesAreAddedToProperties()
        {
            using ApplicationInsightsTarget target = new()
            {
                IncludeGdc = true,
                ContextProperties = { new("global_prop", "${gdc:item=global_prop}") }
            };
            var aiLogger = this.CreateTargetWithGivenConnectionString(target: target);

            NLog.GlobalDiagnosticsContext.Set("global_prop", "global_value");
            aiLogger.Debug("Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("global_value", telemetry.Properties["global_prop"]);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void GlobalDiagnosticContextPropertiesSupplementEventProperties()
        {
            using ApplicationInsightsTarget target = new()
            {
                IncludeGdc = true,
                ContextProperties = { new("global_prop", "${gdc:item=global_prop}") }
            };
            var aiLogger = this.CreateTargetWithGivenConnectionString(target: target);

            NLog.GlobalDiagnosticsContext.Set("global_prop", "global_value");

            var eventInfo = new LogEventInfo(LogLevel.Trace, "TestLogger", "Hello!");
            eventInfo.Properties["Name"] = "Value";
            aiLogger.Log(eventInfo);

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("global_value", telemetry.Properties["global_prop"]);
            Assert.AreEqual("Value", telemetry.Properties["Name"]);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
#pragma warning disable CA1707 // Identifiers should not contain underscores
        public void EventPropertyKeyNameIsAppendedWith_1_IfSameAsGlobalDiagnosticContextKeyName()
#pragma warning restore CA1707 // Identifiers should not contain underscores
        {
            using ApplicationInsightsTarget target = new()
            {
                IncludeGdc = true,
                IncludeEventProperties = true,
                IncludeScopeNested = true,
                IncludeScopeProperties = true
            };
            target.ContextProperties.Add(new TargetPropertyWithContext("Name", "${gdc:item=Name}"));
            var aiLogger = this.CreateTargetWithGivenConnectionString(target: target);

            GlobalDiagnosticsContext.Set("Name", "Global Value");
            var eventInfo = new LogEventInfo(LogLevel.Trace, "TestLogger", "Hello!");
            eventInfo.Properties["Name"] = "Value";
            aiLogger.Log(eventInfo);

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.IsTrue(telemetry.Properties.ContainsKey("Name"), "Key name altered");
            Assert.AreEqual("Value", telemetry.Properties["Name"]);
            Assert.IsTrue(telemetry.Properties.ContainsKey("Name_1"));
            Assert.AreEqual("Global Value", telemetry.Properties["Name_1"]);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void TraceAreEnqueuedInChannelAndContainExceptionMessage()
        {
            var connectionString = "InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/";
            var aiLogger = this.CreateTargetWithGivenConnectionString(connectionString);
            Exception expectedException;

            try
            {
                throw new Exception("Test logging exception");
            }
            catch (Exception exception)
            {
                expectedException = exception;
                aiLogger.Debug(exception, "testing exception scenario");
            }

            var telemetry = (ExceptionTelemetry)this.adapterHelper.Channel.SentItems.First();
            Assert.AreEqual("System.Exception: Test logging exception", telemetry.Message);
            Assert.AreEqual(expectedException.Message, telemetry.Exception.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void CustomMessageIsAddedToExceptionTelemetryCustomProperties()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            try
            {
                throw new Exception("Test logging exception");
            }
            catch (Exception exception)
            {
                aiLogger.Debug(exception, "custom message");
            }

            var telemetry = (ExceptionTelemetry)this.adapterHelper.Channel.SentItems.First();
            Assert.AreEqual("System.Exception: Test logging exception", telemetry.Message);
            Assert.IsTrue(telemetry.Properties["Message"].StartsWith("custom message", StringComparison.Ordinal));
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogTraceIsSentAsVerboseTraceItem()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");

            aiLogger.Trace("trace");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual(SeverityLevel.Verbose, telemetry.SeverityLevel);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogDebugIsSentAsVerboseTraceItem()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");

            aiLogger.Debug("trace");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual(SeverityLevel.Verbose, telemetry.SeverityLevel);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogInfoIsSentAsInformationTraceItem()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");

            aiLogger.Info("trace");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual(SeverityLevel.Information, telemetry.SeverityLevel);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogWarnIsSentAsWarningTraceItem()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");

            aiLogger.Warn("trace");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual(SeverityLevel.Warning, telemetry.SeverityLevel);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogErrorIsSentAsErrorTraceItem()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");

            aiLogger.Error("trace");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual(SeverityLevel.Error, telemetry.SeverityLevel);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogFatalIsSentAsCriticalTraceItem()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=F8474271-D231-45B6-8DD4-D344C309AE69;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");

            aiLogger.Fatal("trace");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual(SeverityLevel.Critical, telemetry.SeverityLevel);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogPropertyDuplicateKeyDuplicateValue()
        {
            using var aiTarget = new ApplicationInsightsTarget();
            var logEventInfo = new LogEventInfo();
            var loggerNameVal = "thisisaloggername";

            logEventInfo.LoggerName = loggerNameVal;
            logEventInfo.Properties.Add("LoggerName", loggerNameVal);

            var traceTelemetry = new TraceTelemetry();

            aiTarget.BuildPropertyBag(logEventInfo, traceTelemetry);

            Assert.IsTrue(traceTelemetry.Properties.ContainsKey("LoggerName"));
            Assert.AreEqual(loggerNameVal, traceTelemetry.Properties["LoggerName"]);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogPropertyDuplicateKeyDifferentValue()
        {
            using var aiTarget = new ApplicationInsightsTarget();
            var logEventInfo = new LogEventInfo();
            var loggerNameVal = "thisisaloggername";
            var loggerNameVal2 = "thisisadifferentloggername";

            logEventInfo.LoggerName = loggerNameVal;
            logEventInfo.Properties.Add("LoggerName", loggerNameVal2);

            var traceTelemetry = new TraceTelemetry();

            aiTarget.BuildPropertyBag(logEventInfo, traceTelemetry);

            Assert.IsTrue(traceTelemetry.Properties.ContainsKey("LoggerName"));
            Assert.AreEqual(loggerNameVal, traceTelemetry.Properties["LoggerName"]);

            Assert.IsTrue(traceTelemetry.Properties.ContainsKey("LoggerName_1"));
            Assert.AreEqual(loggerNameVal2, traceTelemetry.Properties["LoggerName_1"]);
        }


        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogTargetFlushesTelemetryClient()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString();

            using var flushEvent = new System.Threading.ManualResetEvent(false);
            Exception flushException = null;
            void asyncContinuation(Exception ex) { flushException = ex; flushEvent.Set(); }
            aiLogger.Factory.Flush(asyncContinuation, 5000);
            Assert.IsTrue(flushEvent.WaitOne(5000));
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogInfoIsSentAsInformationTraceItemWithAIConnectionString()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Info("Info message");

            var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();
            Assert.AreEqual($"Info message", telemetry.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogTraceIsSentAsVerboseTraceItemWithAIConnectionString()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Trace("Trace message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Trace message", telemetry.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogDebugIsSentAsVerboseTraceItemWithAIConnectionString()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Debug("Debug Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Debug Message", telemetry.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogWarnIsSentAsWarningTraceItemWithAIConnectionString()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");

            aiLogger.Warn("Warn message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Warn message", telemetry.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogErrorIsSentAsVerboseTraceItemWithAIConnectionString()
        {
            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Error("Error Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Error Message", telemetry.Message);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogInfoContainsCurrentActivity()
        {
            using Activity activity = new(nameof(NLogInfoContainsCurrentActivity));
            activity.Start();

            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Info("Info message");

            var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();
            Assert.AreEqual($"Info message", telemetry.Message);
            Assert.AreEqual(activity.TraceId.ToString(), telemetry.Context.Operation.Id);
            Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogErrorContainsCurrentActivity()
        {
            using Activity activity = new(nameof(NLogErrorContainsCurrentActivity));
            activity.Start();

            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Error("Error Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Error Message", telemetry.Message);
            Assert.AreEqual(activity.TraceId.ToString(), telemetry.Context.Operation.Id);
            Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogInfoDoesNotContainTraceIdIfLayoutIsEmpty()
        {
            using Activity activity = new(nameof(NLogInfoDoesNotContainTraceIdIfLayoutIsEmpty));
            activity.Start();

            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/", traceIdLayout: string.Empty);
            aiLogger.Info("Info message");

            var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();
            Assert.AreEqual($"Info message", telemetry.Message);
            Assert.IsTrue(string.IsNullOrWhiteSpace(telemetry.Context.Operation.Id));
            Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogErrorDoesNotContainTraceIdIfLayoutIsEmpty()
        {
            using Activity activity = new(nameof(NLogErrorDoesNotContainTraceIdIfLayoutIsEmpty));
            activity.Start();

            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/", traceIdLayout: string.Empty);
            aiLogger.Error("Error Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Error Message", telemetry.Message);
            Assert.IsTrue(string.IsNullOrWhiteSpace(telemetry.Context.Operation.Id));
            Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogInfoDoesNotContainSpanIdIfLayoutIsEmpty()
        {
            using Activity activity = new(nameof(NLogInfoDoesNotContainSpanIdIfLayoutIsEmpty));
            activity.Start();
            var originalActivity = Activity.Current;
            Activity.Current = activity;

            try
            {
                var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/", spanIdLayout: string.Empty);
                aiLogger.Info("Info message");

                var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();
                Assert.AreEqual($"Info message", telemetry.Message);
                Assert.AreEqual(activity.TraceId.ToString(), telemetry.Context.Operation.Id);
                Assert.IsTrue(string.IsNullOrWhiteSpace(telemetry.Context.Operation.ParentId));
            }
            finally
            {
                Activity.Current = originalActivity;
            }
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogErrorDoesNotContainSpanIdIfLayoutIsEmpty()
        {
            using Activity activity = new(nameof(NLogErrorDoesNotContainSpanIdIfLayoutIsEmpty));
            activity.Start();

            var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/", spanIdLayout: string.Empty);
            aiLogger.Error("Error Message");

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Error Message", telemetry.Message);
            Assert.AreEqual(activity.TraceId.ToString(), telemetry.Context.Operation.Id);
            Assert.IsTrue(string.IsNullOrWhiteSpace(telemetry.Context.Operation.ParentId));
        }

#if NET6_0_OR_GREATER
        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogInfoDoesNotContainTraceIdIfValueIsAllZeroes()
        {
            Activity.TraceIdGenerator = () => default;
            try
            {
                using Activity activity = new(nameof(NLogInfoDoesNotContainTraceIdIfValueIsAllZeroes));
                activity.Start();
                var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
                aiLogger.Info("Info message");

                var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();
                Assert.AreEqual($"Info message", telemetry.Message);
                Assert.IsTrue(string.IsNullOrWhiteSpace(telemetry.Context.Operation.Id));
                Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
            }
            finally
            {
                Activity.TraceIdGenerator = ActivityTraceId.CreateRandom;
            }
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogErrorDoesNotContainTraceIdIfValueIsAllZeroes()
        {
            Activity.TraceIdGenerator = () => default;
            try
            {
                using Activity activity = new(nameof(NLogErrorDoesNotContainTraceIdIfValueIsAllZeroes));
                activity.Start();

                var aiLogger = this.CreateTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
                aiLogger.Error("Error Message");

                var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
                Assert.AreEqual("Error Message", telemetry.Message);
                Assert.IsTrue(string.IsNullOrWhiteSpace(telemetry.Context.Operation.Id));
                Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
            }
            finally
            {
                Activity.TraceIdGenerator = ActivityTraceId.CreateRandom;
            }
        }
#endif // NET6_0_OR_GREATER

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogInfoContainsCurrentActivityAsyncTarget()
        {
            using Activity activity = new(nameof(NLogInfoContainsCurrentActivityAsyncTarget));
            activity.Start();

            var aiLogger = this.CreateAsyncTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Info("Info message");
            aiLogger.Factory.Flush();

            var telemetry = (TraceTelemetry)this.adapterHelper.Channel.SentItems.First();
            Assert.AreEqual($"Info message", telemetry.Message);
            Assert.AreEqual(activity.TraceId.ToString(), telemetry.Context.Operation.Id);
            Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
        }

        [TestMethod]
        [TestCategory("NLogTarget")]
        public void NLogErrorContainsCurrentActivityAsyncTarget()
        {
            using Activity activity = new(nameof(NLogErrorContainsCurrentActivityAsyncTarget));
            activity.Start();

            var aiLogger = this.CreateAsyncTargetWithGivenConnectionString("InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/");
            aiLogger.Error("Error Message");
            aiLogger.Factory.Flush();

            var telemetry = this.adapterHelper.Channel.SentItems.FirstOrDefault() as TraceTelemetry;
            Assert.AreEqual("Error Message", telemetry.Message);
            Assert.AreEqual(activity.TraceId.ToString(), telemetry.Context.Operation.Id);
            Assert.AreEqual(activity.SpanId.ToHexString(), telemetry.Context.Operation.ParentId);
        }

        private void VerifyMessagesInMockChannel(Logger aiLogger, string instrumentationKey)
        {
            aiLogger.Trace("Sample trace message");
            aiLogger.Debug("Sample debug message");
            aiLogger.Info("Sample informational message");
            aiLogger.Warn("Sample warning message");
            aiLogger.Error("Sample error message");
            aiLogger.Fatal("Sample fatal error message");

            AdapterHelper.ValidateChannel(this.adapterHelper, instrumentationKey, 6);
        }

        private Logger CreateTargetWithGivenConnectionString(
            string connectionString = "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/",
            Action<Logger> loggerAction = null,
            ApplicationInsightsTarget target = null,
            string traceIdLayout = null,
            string spanIdLayout = null)
        {
#pragma warning disable CA2000 // Dispose objects before losing scope - Caller is responsible for disposal
            target ??= new ApplicationInsightsTarget();
#pragma warning restore CA2000 // Dispose objects before losing scope - Caller is responsible for disposal

            target.TelemetryConfigurationFactory = () => new TelemetryConfiguration() { TelemetryChannel = this.adapterHelper.Channel };

            target.ConnectionString = connectionString;
            if (traceIdLayout != null)
            {
                target.TraceId = traceIdLayout;
            }

            if (spanIdLayout != null)
            {
                target.SpanId = spanIdLayout;
            }

            var rule = new LoggingRule("*", LogLevel.Trace, target);
            var config = new LoggingConfiguration();
            config.AddTarget("AITarget", target);
            config.LoggingRules.Add(rule);

            LogFactory logFactory = new()
            {
                Configuration = config
            };

            var aiLogger = logFactory.GetLogger("AITarget");

            if (loggerAction != null)
            {
                loggerAction(aiLogger);
                target.Dispose();
                return null;
            }

            return aiLogger;
        }

        private Logger CreateAsyncTargetWithGivenConnectionString(
            string connectionString = "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://westeurope.in.applicationinsights.azure.example.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.example.com/",
            Action<Logger> loggerAction = null,
            ApplicationInsightsTarget target = null,
            string traceIdLayout = null,
            string spanIdLayout = null)
        {
#pragma warning disable CA2000 // Dispose objects before losing scope - Caller is responsible for disposal
            target ??= new ApplicationInsightsTarget();
#pragma warning restore CA2000 // Dispose objects before losing scope - Caller is responsible for disposal

            target.TelemetryConfigurationFactory = () => new TelemetryConfiguration() { TelemetryChannel = this.adapterHelper.Channel };

            target.ConnectionString = connectionString;
            if (traceIdLayout != null)
            {
                target.TraceId = traceIdLayout;
            }

            if (spanIdLayout != null)
            {
                target.SpanId = spanIdLayout;
            }

#pragma warning disable CA2000 // Dispose objects before losing scope - Caller is responsible for disposal
            var asyncWrapper = new AsyncTargetWrapper
            {
                Name = "async",
                WrappedTarget = target,
                QueueLimit = 5000,
                BatchSize = 100,
                TimeToSleepBetweenBatches = 100,
                OverflowAction = AsyncTargetWrapperOverflowAction.Grow
            };
#pragma warning restore CA2000 // Dispose objects before losing scope - Caller is responsible for disposal

            var rule = new LoggingRule("*", LogLevel.Trace, asyncWrapper);
            var config = new LoggingConfiguration();
            config.AddTarget("AITarget", asyncWrapper);
            config.LoggingRules.Add(rule);

            LogFactory logFactory = new()
            {
                Configuration = config
            };

            var aiLogger = logFactory.GetLogger("AITarget");

            if (loggerAction != null)
            {
                loggerAction(aiLogger);
                target.Dispose();
                return null;
            }

            return aiLogger;
        }
    }
}