integration test

Author: tippmar-nr

tests/Agent/IntegrationTests/IntegrationTestHelpers/AgentLogBase.cs

@@ -86,6 +86,9 @@ public abstract class AgentLogBase
         public const string WrapperExceptionLogLineRegex = ErrorLogLinePrefixRegex + "An exception occurred in a wrapper";
         public const string ApplicationErrorLogLineRegex = DebugLogLinePrefixRegex + "Noticed application error";
 
+        // explain plan failure
+        public const string ExplainPlainFailureLogLineRegex = DebugLogLinePrefixRegex + "Unable to execute explain plan for query: (.*)";
+
         public AgentLogBase(ITestOutputHelper testLogger)
         {
             _testLogger = testLogger;

tests/Agent/IntegrationTests/SharedApplications/Common/MultiFunctionApplicationHelpers/NetStandardLibraries/MsSql/MicrosoftDataSqlClientExerciser.cs

@@ -12,6 +12,7 @@
 using NewRelic.Agent.IntegrationTests.Shared.ReflectionHelpers;
 using NewRelic.Api.Agent;
 using System.Threading;
+using System;
 
 namespace MultiFunctionApplicationHelpers.NetStandardLibraries.MsSql
 {
@@ -265,6 +266,63 @@ public void Wait(int millisecondsTimeOut)
             Thread.Sleep(millisecondsTimeOut);
         }
 
+#if NET9_0
+        [LibraryMethod]
+        public async Task MsSqlCreateStoredProcWithTempTable(string procedureName)
+        {
+            var createProcedure = $@"
+                CREATE OR ALTER PROCEDURE {procedureName}
+                AS
+                BEGIN
+                    -- Create a temporary table and insert data into it using SELECT INTO
+                    SELECT 
+                        Id,
+                        FirstName
+                    INTO #TempTable
+                    FROM 
+                        TeamMembers;
+
+                    -- Select all rows from the temporary table
+                    SELECT * FROM #TempTable;
+                END;";
+
+            await using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            await using var command = new SqlCommand(createProcedure, connection);
+            await command.ExecuteNonQueryAsync();
+
+        }
+
+        [LibraryMethod]
+        [Transaction]
+        [MethodImpl(MethodImplOptions.NoOptimization | MethodImplOptions.NoInlining)]
+        public async Task MsSqlStoredProcWithTempTable(string procedureName)
+        {
+            await using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            await using var command = connection.CreateCommand();
+            command.CommandText = procedureName;
+            command.CommandType = System.Data.CommandType.StoredProcedure;
+
+            // execute the command
+            await using var reader = await command.ExecuteReaderAsync();
+
+        }
+
+        [LibraryMethod]
+        public async Task MsSqlDropStoredProcWithTempTable(string procedureName)
+        {
+            var dropProcedureSql = string.Format(DropProcedureSql, procedureName);
+            await using var connection = new SqlConnection(_connectionString);
+            await connection.OpenAsync();
+
+            await using var command = new SqlCommand(dropProcedureSql, connection);
+            await command.ExecuteNonQueryAsync();
+        }
+#endif
+
         private void EnsureProcedure(string procedureName, DbParameter[] dbParameters)
         {
             var parameters = string.Join(", ", dbParameters.Select(x => $"{x.ParameterName} {x.DbTypeName}"));

tests/Agent/IntegrationTests/UnboundedIntegrationTests/MsSql/MsSqlFailedExplainPlanTests.cs

@@ -0,0 +1,70 @@
+// Copyright 2020 New Relic, Inc. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestPlatform.Utilities;
+using NewRelic.Agent.IntegrationTestHelpers;
+using NewRelic.Agent.IntegrationTestHelpers.RemoteServiceFixtures;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace NewRelic.Agent.UnboundedIntegrationTests.MsSql
+{
+    public class MsSqlFailedExplainPlanTests : NewRelicIntegrationTest<ConsoleDynamicMethodFixtureCoreLatest>
+    {
+        private readonly ConsoleDynamicMethodFixtureCoreLatest _fixture;
+
+        public MsSqlFailedExplainPlanTests(ConsoleDynamicMethodFixtureCoreLatest fixture, ITestOutputHelper outputHelper) : base(fixture)
+        {
+            var exerciserName = "MicrosoftDataSqlClientExerciser";
+
+            _fixture = fixture;
+            _fixture.TestLogger = outputHelper;
+
+            var procedureName = Utilities.GenerateProcedureName();
+
+            _fixture.AddCommand($"{exerciserName} MsSqlCreateStoredProcWithTempTable {procedureName}");
+            _fixture.AddCommand($"{exerciserName} MsSqlStoredProcWithTempTable {procedureName}");
+            _fixture.AddCommand($"{exerciserName} MsSqlStoredProcWithTempTable {procedureName}");
+            _fixture.AddCommand($"{exerciserName} MsSqlDropStoredProcWithTempTable {procedureName}");
+
+            _fixture.AddActions
+            (
+                setupConfiguration: () =>
+                {
+                    var configPath = fixture.DestinationNewRelicConfigFilePath;
+                    var configModifier = new NewRelicConfigModifier(configPath);
+                    configModifier.ConfigureFasterMetricsHarvestCycle(15);
+                    configModifier.ConfigureFasterTransactionTracesHarvestCycle(15);
+                    configModifier.ConfigureFasterSqlTracesHarvestCycle(15);
+
+                    configModifier.ForceTransactionTraces();
+                    configModifier.SetLogLevel("finest");       //This has to stay at finest to ensure parameter check security
+
+                    CommonUtils.ModifyOrCreateXmlAttributeInNewRelicConfig(configPath, new[] { "configuration", "transactionTracer" }, "explainEnabled", "true");
+                    CommonUtils.ModifyOrCreateXmlAttributeInNewRelicConfig(configPath, new[] { "configuration", "transactionTracer" }, "recordSql", "raw");
+                    CommonUtils.ModifyOrCreateXmlAttributeInNewRelicConfig(configPath, new[] { "configuration", "transactionTracer" }, "explainThreshold", "1");
+                    CommonUtils.ModifyOrCreateXmlAttributeInNewRelicConfig(configPath, new[] { "configuration", "datastoreTracer", "queryParameters" }, "enabled", "true");
+                },
+                exerciseApplication: () =>
+                {
+                    _fixture.AgentLog.WaitForLogLine(AgentLogBase.ExplainPlainFailureLogLineRegex, TimeSpan.FromMinutes(1));
+                }
+            );
+
+            _fixture.Initialize();
+
+        }
+
+        [Fact]
+        public void Test()
+        {
+            // verify that the log contains one explain plan failure log line - second call to the stored proc doesn't try to generate an explain plan
+            Assert.Single(_fixture.AgentLog.TryGetLogLines(AgentLogBase.ExplainPlainFailureLogLineRegex));
+        }
+    }
+}