feature: Add .NET 8+ support for System.Data.Odbc

src/Agent/NewRelic/Agent/Core/Attributes/AttributeDefinitionService.cs

@@ -148,7 +148,6 @@ public interface IAttributeDefinitions
         AttributeDefinition<string, string> MessagingDestinationPublishName { get; }
     }
 
-
     public class AttributeDefinitionService : ConfigurationBasedService, IAttributeDefinitionService
     {
         public IAttributeDefinitions AttributeDefs { get; private set; }

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Helpers/StringSeparators.cs

@@ -8,6 +8,9 @@ public static class StringSeparators
         public const char PathSeparatorChar = '/';
         public static readonly char[] PathSeparator = { PathSeparatorChar };
 
+        public const char BackslashChar = '\\';
+        public static readonly char[] Backslash = { BackslashChar };
+
         public const char CommaChar = ',';
         public static readonly char[] Comma = { CommaChar };
 

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/IConnectionStringParser.cs

@@ -43,6 +43,8 @@ private static IConnectionStringParser GetConnectionParser(DatastoreVendor vendo
                     return new IbmDb2ConnectionStringParser(connectionString);
                 case DatastoreVendor.Redis:
                     return new StackExchangeRedisConnectionStringParser(connectionString);
+                case DatastoreVendor.ODBC:
+                    return new OdbcConnectionStringParser(connectionString);
                 default:
                     return null;
             }

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/IbmDb2ConnectionStringParser.cs

@@ -1,10 +1,10 @@
 // Copyright 2020 New Relic, Inc. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-using NewRelic.Agent.Extensions.Providers.Wrapper;
 using System.Collections.Generic;
 using System.Data.Common;
 using System.Linq;
+using NewRelic.Agent.Helpers;
 
 namespace NewRelic.Agent.Extensions.Parsing.ConnectionString
 {
@@ -35,7 +35,7 @@ private string ParseHost()
             var host = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _hostKeys)?.Value;
             if (host == null) return null;
 
-            var endOfHostname = host.IndexOf(':');
+            var endOfHostname = host.IndexOf(StringSeparators.ColonChar);
             return endOfHostname == -1 ? host : host.Substring(0, endOfHostname);
         }
 
@@ -44,8 +44,8 @@ private string ParsePortPathOrId()
             var host = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _hostKeys)?.Value;
             if (host == null) return null;
 
-            if (host.Contains(':'))
-                return host.Substring(host.IndexOf(':') + 1);
+            if (host.Contains(StringSeparators.ColonChar))
+                return host.Substring(host.IndexOf(StringSeparators.ColonChar) + 1);
 
             return "default";
         }

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/MsSqlConnectionStringParser.cs

@@ -1,10 +1,10 @@
 // Copyright 2020 New Relic, Inc. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-using NewRelic.Agent.Extensions.Providers.Wrapper;
 using System.Collections.Generic;
 using System.Data.Common;
 using System.Linq;
+using NewRelic.Agent.Helpers;
 
 namespace NewRelic.Agent.Extensions.Parsing.ConnectionString
 {
@@ -38,8 +38,8 @@ private string ParseHost()
             // Example of want we would need to process: win-database.pdx.vm.datanerd.us,1433\SQLEXPRESS
             try
             {
-                var splitIndex = host.IndexOf(',');
-                if (splitIndex == -1) splitIndex = host.IndexOf('\\');
+                var splitIndex = host.IndexOf(StringSeparators.CommaChar);
+                if (splitIndex == -1) splitIndex = host.IndexOf(StringSeparators.BackslashChar);
                 host = splitIndex == -1 ? host : host.Substring(0, splitIndex);
             }
             catch
@@ -56,11 +56,11 @@ private string ParsePortPathOrId()
 
             try
             {
-                if (portPathOrId.IndexOf(',') != -1)
+                if (portPathOrId.IndexOf(StringSeparators.CommaChar) != -1)
                 {
-                    var startOfValue = portPathOrId.IndexOf(',') + 1;
-                    var endOfValue = portPathOrId.Contains('\\')
-                        ? portPathOrId.IndexOf('\\')
+                    var startOfValue = portPathOrId.IndexOf(StringSeparators.CommaChar) + 1;
+                    var endOfValue = portPathOrId.Contains(StringSeparators.BackslashChar)
+                        ? portPathOrId.IndexOf(StringSeparators.BackslashChar)
                         : portPathOrId.Length;
                     return (startOfValue > 0) ? portPathOrId.Substring(startOfValue, endOfValue - startOfValue) : null;
                 }
@@ -80,9 +80,9 @@ private string ParseInstanceName()
 
             try
             {
-                if (instanceName.IndexOf('\\') != -1)
+                if (instanceName.IndexOf(StringSeparators.BackslashChar) != -1)
                 {
-                    var startOfValue = instanceName.IndexOf('\\') + 1;
+                    var startOfValue = instanceName.IndexOf(StringSeparators.BackslashChar) + 1;
                     var endOfValue = instanceName.Length;
                     return (startOfValue > 0) ? instanceName.Substring(startOfValue, endOfValue - startOfValue) : null;
                 }

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/MySqlConnectionStringParser.cs

@@ -1,9 +1,9 @@
 // Copyright 2020 New Relic, Inc. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-using NewRelic.Agent.Extensions.Providers.Wrapper;
 using System.Collections.Generic;
 using System.Data.Common;
+using NewRelic.Agent.Helpers;
 
 namespace NewRelic.Agent.Extensions.Parsing.ConnectionString
 {
@@ -24,7 +24,7 @@ public ConnectionInfo GetConnectionInfo(string utilizationHostName)
         {
             var host = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _hostKeys)?.Value;
 
-            var hasMultipleHosts = host != null && host.IndexOf(',') != -1;
+            var hasMultipleHosts = host != null && host.IndexOf(StringSeparators.CommaChar) != -1;
             if (hasMultipleHosts)
                 host = null;
             else if (host != null)

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/OdbcConnectionStringParser.cs

@@ -0,0 +1,115 @@
+// Copyright 2020 New Relic, Inc. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+using NewRelic.Agent.Helpers;
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Linq;
+
+namespace NewRelic.Agent.Extensions.Parsing.ConnectionString
+{
+    public class OdbcConnectionStringParser : IConnectionStringParser
+    {
+        private static readonly List<string> _hostKeys = new List<string> { "server", "data source", "hostname" };
+        private static readonly List<string> _portKeys = new List<string> { "port" };
+        private static readonly List<string> _databaseNameKeys = new List<string> { "database" };
+
+        private readonly DbConnectionStringBuilder _connectionStringBuilder;
+
+        public OdbcConnectionStringParser(string connectionString)
+        {
+            _connectionStringBuilder = new DbConnectionStringBuilder { ConnectionString = connectionString };
+        }
+
+        public ConnectionInfo GetConnectionInfo(string utilizationHostName)
+        {
+            var host = ParseHost();
+            if (host != null) host = ConnectionStringParserHelper.NormalizeHostname(host, utilizationHostName);
+            var portPathOrId = ParsePortPathOrId();
+            var databaseName = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _databaseNameKeys)?.Value;
+            var instanceName = ParseInstanceName();
+            return new ConnectionInfo(host, portPathOrId, databaseName, instanceName);
+        }
+
+        private string ParseHost()
+        {
+            var host = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _hostKeys)?.Value;
+            if (host == null) return null;
+
+            // Example of want we would need to process: win-database.pdx.vm.datanerd.us,1433\SQLEXPRESS
+            try
+            {
+                var splitIndex = host.IndexOf(StringSeparators.CommaChar);
+                if (splitIndex == -1) splitIndex = host.IndexOf(StringSeparators.BackslashChar);
+                host = splitIndex == -1 ? host : host.Substring(0, splitIndex);
+            }
+            catch
+            {
+                return null;
+            }
+            var endOfHostname = host.IndexOf(StringSeparators.ColonChar);
+            return endOfHostname == -1 ? host : host.Substring(0, endOfHostname);
+        }
+
+        private string ParsePortPathOrId()
+        {
+            // Some ODBC drivers use the "port" key to specify the port number
+            var portPathOrId = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _portKeys)?.Value;
+            if (!string.IsNullOrWhiteSpace(portPathOrId))
+            {
+                return portPathOrId;
+
+            }
+
+            // Some ODBC drivers include the port in the "server" or "data source" key
+            portPathOrId = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _hostKeys)?.Value;
+            if (portPathOrId == null) return null;
+
+            try
+            {
+                if (portPathOrId.IndexOf(StringSeparators.ColonChar) != -1)
+                {
+                    var startOfValue = portPathOrId.IndexOf(StringSeparators.ColonChar) + 1;
+                    var endOfValue = portPathOrId.Length;
+                    return (startOfValue > 0) ? portPathOrId.Substring(startOfValue, endOfValue - startOfValue) : null;
+                }
+                if (portPathOrId.IndexOf(StringSeparators.CommaChar) != -1)
+                {
+                    var startOfValue = portPathOrId.IndexOf(StringSeparators.CommaChar) + 1;
+                    var endOfValue = portPathOrId.Contains(StringSeparators.BackslashChar)
+                        ? portPathOrId.IndexOf(StringSeparators.BackslashChar)
+                        : portPathOrId.Length;
+                    return (startOfValue > 0) ? portPathOrId.Substring(startOfValue, endOfValue - startOfValue) : null;
+                }
+            }
+            catch
+            {
+                return null;
+            }
+
+            return "default";
+        }
+
+        private string ParseInstanceName()
+        {
+            var instanceName = ConnectionStringParserHelper.GetKeyValuePair(_connectionStringBuilder, _hostKeys)?.Value;
+            if (instanceName == null) return null;
+
+            try
+            {
+                if (instanceName.IndexOf(StringSeparators.BackslashChar) != -1)
+                {
+                    var startOfValue = instanceName.IndexOf(StringSeparators.BackslashChar) + 1;
+                    var endOfValue = instanceName.Length;
+                    return (startOfValue > 0) ? instanceName.Substring(startOfValue, endOfValue - startOfValue) : null;
+                }
+            }
+            catch
+            {
+                return null;
+            }
+
+            return null;
+        }
+    }
+}

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/OracleConnectionStringParser.cs

@@ -5,7 +5,6 @@
 using System.Data.Common;
 using System.Linq;
 using NewRelic.Agent.Helpers;
-using NewRelic.Agent.Extensions.Providers.Wrapper;
 
 namespace NewRelic.Agent.Extensions.Parsing.ConnectionString
 {

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/PostgresConnectionStringParser.cs

@@ -1,7 +1,6 @@
 // Copyright 2020 New Relic, Inc. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-using NewRelic.Agent.Extensions.Providers.Wrapper;
 using System.Collections.Generic;
 using System.Data.Common;
 

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/ConnectionString/StackExchangeRedisConnectionStringParser.cs

@@ -3,7 +3,6 @@
 
 using System.Linq;
 using NewRelic.Agent.Helpers;
-using NewRelic.Agent.Extensions.Providers.Wrapper;
 
 namespace NewRelic.Agent.Extensions.Parsing.ConnectionString
 {

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Parsing/SqlWrapperHelper.cs

@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Data;
 using System.Data.SqlTypes;
 using System.Globalization;
+using System.Text.RegularExpressions;
 #if NETFRAMEWORK
-using System.Data.Odbc;
 using System.Data.OleDb;
 #endif
 using NewRelic.Agent.Api;
@@ -19,6 +20,9 @@ public static class SqlWrapperHelper
     {
         private const string NullQueryParameterValue = "Null";
 
+        private static Regex _getDriverFromConnectionStringRegex = new Regex(@"DRIVER\=\{(.+?)\}", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+        private static ConcurrentDictionary<string, DatastoreVendor> _vendorNameCache = new ConcurrentDictionary<string, DatastoreVendor>();
+
         /// <summary>
         /// Gets the name of the datastore being used by a dbCommand.
         /// </summary>
@@ -29,20 +33,34 @@ public static DatastoreVendor GetVendorName(IDbCommand command)
         {
 
 #if NETFRAMEWORK
-			// If this is an OdbcCommand, the only way to give the data store name is by looking at the connection driver
-
-			var odbcCommand = command as OdbcCommand;
-			if (odbcCommand != null && odbcCommand.Connection != null)
-				return ExtractVendorNameFromString(odbcCommand.Connection.Driver);
+            // If this is an OleDbCommand, the only way to give the data store name is by looking at the connection provider
+            var oleCommand = command as OleDbCommand;
+            if (oleCommand != null && oleCommand.Connection != null)
+                return ExtractVendorNameFromString(oleCommand.Connection.Provider);
 
-			// If this is an OleDbCommand, the only way to give the data store name is by looking at the connection provider
-			var oleCommand = command as OleDbCommand;
-			if (oleCommand != null && oleCommand.Connection != null)
-				return ExtractVendorNameFromString(oleCommand.Connection.Provider);
 #endif
             return GetVendorName(command.GetType().Name);
         }
 
+        public static DatastoreVendor GetVendorNameFromOdbcConnectionString(string connectionString)
+        {
+            // Example connection string: DRIVER={SQL Server Native Client 11.0};Server=127.0.0.1;Database=NewRelic;Trusted_Connection=no;UID=sa;PWD=password;Encrypt=no;
+            if (_vendorNameCache.TryGetValue(connectionString, out DatastoreVendor vendor))
+            {
+                return vendor;
+            }
+
+            var match = _getDriverFromConnectionStringRegex.Match(connectionString);
+            if (match.Success)
+            {
+                var driver = match.Groups[1].Value;
+                vendor = ExtractVendorNameFromString(driver);
+                _vendorNameCache[connectionString] = vendor;
+                return vendor;
+            }
+            return DatastoreVendor.ODBC;
+        }
+
         public static DatastoreVendor GetVendorName(string typeName)
         {
 
@@ -61,7 +79,7 @@ public static DatastoreVendor GetVendorName(string typeName)
             { "OracleCommand", DatastoreVendor.Oracle },
             { "OracleDatabase", DatastoreVendor.Oracle },
             { "NpgsqlCommand", DatastoreVendor.Postgres },
-            { "DB2Command", DatastoreVendor.IBMDB2 },
+            { "DB2Command", DatastoreVendor.IBMDB2 }
         };
 
         /// <summary>
@@ -71,6 +89,9 @@ public static DatastoreVendor GetVendorName(string typeName)
         /// <returns></returns>
         private static DatastoreVendor ExtractVendorNameFromString(string text)
         {
+            // Note that, because of the ordering of the following checks, an ODBC connection string for a known DB vendor should result in that vendor
+            // being returned, instead of ODBC
+            // example: Driver={ODBC Driver 17 for SQL Server};Server=myServerAddress;Database=myDataBase;
             if (text.IndexOf("SQL Server", StringComparison.OrdinalIgnoreCase) != -1 || text.IndexOf("SQLServer", StringComparison.OrdinalIgnoreCase) != -1)
                 return DatastoreVendor.MSSQL;
 
@@ -86,6 +107,11 @@ private static DatastoreVendor ExtractVendorNameFromString(string text)
             if (text.IndexOf("DB2", StringComparison.OrdinalIgnoreCase) != -1 || text.IndexOf("IBM", StringComparison.OrdinalIgnoreCase) != -1)
                 return DatastoreVendor.IBMDB2;
 
+            // This works for redshift since the driver reports as "Amazon Redshift (x64)"
+            // Other drivers may not report as expected
+            if (text.IndexOf("ODBC", StringComparison.OrdinalIgnoreCase) != -1 || text.IndexOf("Redshift", StringComparison.OrdinalIgnoreCase) != -1)
+                return DatastoreVendor.ODBC;
+
             return DatastoreVendor.Other;
         }
 

src/Agent/NewRelic/Agent/Extensions/NewRelic.Agent.Extensions/Providers/Wrapper/Constants.cs

@@ -81,6 +81,7 @@ public enum DatastoreVendor
         CosmosDB,
         Elasticsearch,
         DynamoDB,
+        ODBC,
         Other
     }
 

src/Agent/NewRelic/Agent/Extensions/Providers/Wrapper/Sql/Instrumentation.xml

@@ -13,6 +13,13 @@ SPDX-License-Identifier: Apache-2.0
         <exactMethodMatcher methodName="ExecuteNonQuery" />
         <exactMethodMatcher methodName="ExecuteScalar" />
       </match>
+
+      <!-- .NET Core ODBC driver -->
+      <match assemblyName="System.Data.Odbc" className="System.Data.Odbc.OdbcCommand">
+        <exactMethodMatcher methodName="ExecuteReader" parameters="System.Data.CommandBehavior" />
+        <exactMethodMatcher methodName="ExecuteNonQuery" />
+        <exactMethodMatcher methodName="ExecuteScalar" />
+      </match>
     </tracerFactory>
 
     <tracerFactory name="OleDbCommandTracer">