feat: add support for monitoring azure sql managed instance (#236)

feat: add support for monitoring azure sql managed instance (#236)

Author: sairaj18

CHANGELOG.md

@@ -11,6 +11,7 @@ Unreleased section should follow [Release Toolkit](https://github.com/newrelic/r
 
 ### enhancement
 - Add support for monitoring Azure SQL Database
+- Add support for monitoring Azure SQL Managed Instance
 
 ## v2.18.2 - 2025-06-03
 

src/database/sql_database.go

@@ -12,10 +12,13 @@ import (
 	"github.com/newrelic/nri-mssql/src/connection"
 )
 
-// databaseNameQuery gets all database names
-const databaseNameQuery = "select name as db_name from sys.databases where name not in ('master', 'tempdb', 'msdb', 'model', 'rdsadmin', 'distribution', 'model_msdb', 'model_replicatedmaster')"
-const engineEditionQuery = "SELECT SERVERPROPERTY('EngineEdition') AS EngineEdition;"
-const AzureSQLDatabaseEngineEditionNumber = 5
+const (
+	// databaseNameQuery gets all database names
+	databaseNameQuery                          = "select name as db_name from sys.databases where name not in ('master', 'tempdb', 'msdb', 'model', 'rdsadmin', 'distribution', 'model_msdb', 'model_replicatedmaster')"
+	engineEditionQuery                         = "SELECT SERVERPROPERTY('EngineEdition') AS EngineEdition;"
+	AzureSQLDatabaseEngineEditionNumber        = 5
+	AzureSQLManagedInstanceEngineEditionNumber = 8
+)
 
 // NameRow is a row result in the databaseNameQuery
 type NameRow struct {
@@ -127,6 +130,7 @@ func GetEngineEdition(connection *connection.SQLConnection) (int, error) {
 		log.Debug("EngineEdition query returned empty output.")
 		return 0, nil
 	} else {
+		log.Debug("Detected EngineEdition: %d", engineEdition[0])
 		return engineEdition[0], nil
 	}
 }

src/database/sql_database_test.go

@@ -13,8 +13,6 @@ import (
 	"gopkg.in/DATA-DOG/go-sqlmock.v1"
 )
 
-const azureSQLManagedInstanceEngineEditionNumber = 8
-
 func Test_createDatabaseEntities_QueryError(t *testing.T) {
 	i, err := integration.New("test", "1.0.0")
 	if err != nil {
@@ -206,10 +204,10 @@ func TestGetEngineEdition(t *testing.T) {
 			name: "Successful query - Other SQL Server",
 			setupMock: func(mock sqlmock.Sqlmock) {
 				expectedRows := sqlmock.NewRows([]string{"EngineEdition"}).
-					AddRow(azureSQLManagedInstanceEngineEditionNumber)
+					AddRow(AzureSQLManagedInstanceEngineEditionNumber)
 				mock.ExpectQuery("SELECT (.+)").WillReturnRows(expectedRows)
 			},
-			expectedEdition: azureSQLManagedInstanceEngineEditionNumber,
+			expectedEdition: AzureSQLManagedInstanceEngineEditionNumber,
 			expectError:     false,
 		},
 		{
@@ -260,7 +258,7 @@ func TestIsAzureSQLDatabase(t *testing.T) {
 		},
 		{
 			name:          "Azure SQL Managed Instance",
-			engineEdition: azureSQLManagedInstanceEngineEditionNumber,
+			engineEdition: AzureSQLManagedInstanceEngineEditionNumber,
 			expected:      false,
 		},
 	}

src/inventory/inventory.go

@@ -81,8 +81,9 @@ func setItemOrLog(instanceEntity *integration.Entity, key string, value interfac
 
 // Bucket for processor functions
 var spConfigProcessorFunctionSet = metrics.EngineSet[spConfigItemsProcessor]{
-	Default:          processSPConfigItems,
-	AzureSQLDatabase: processAzureSQLDatabaseSPConfigItems,
+	Default:                 processSPConfigItems,
+	AzureSQLDatabase:        processAzureSQLDatabaseSPConfigItems,
+	AzureSQLManagedInstance: processSPConfigItems,
 }
 
 func processSPConfigItems(instanceEntity *integration.Entity, connection *connection.SQLConnection) error {

src/metrics/database_metric_definitions.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/newrelic/infra-integrations-sdk/v3/log"
 	"github.com/newrelic/nri-mssql/src/database"
 )
 
@@ -103,6 +102,41 @@ var databaseDefinitionsForAzureSQLDatabase = []*QueryDefinition{
 	},
 }
 
+var databaseDefinitionsForAzureSQLManagedInstance = []*QueryDefinition{
+	{
+		query: `
+			SELECT 
+				sd.name AS db_name,
+				spc.cntr_value AS log_growth 
+			FROM sys.dm_os_performance_counters spc WITH (NOLOCK)
+			INNER JOIN sys.databases sd 
+				ON sd.physical_database_name = spc.instance_name
+			WHERE spc.object_name LIKE '%:Databases%'
+				AND spc.counter_name = 'Log Growths'
+				AND sd.name NOT IN ('master', 'tempdb', 'msdb', 'model', 'rdsadmin', 'distribution', 'model_msdb', 'model_replicatedmaster')
+				AND spc.instance_name NOT IN ('_Total', 'mssqlsystemresource', 'master', 'tempdb', 'msdb', 'model', 'rdsadmin', 'distribution', 'model_msdb', 'model_replicatedmaster')
+		`,
+		dataModels: &[]struct {
+			database.DataModel
+			LogGrowth int `db:"log_growth" metric_name:"log.transactionGrowth" source_type:"gauge"`
+		}{},
+	},
+	{
+		query: `		
+			SELECT
+				DB_NAME(database_id) AS db_name,
+				SUM(io_stall) AS io_stalls
+				FROM sys.dm_io_virtual_file_stats(null,null)
+			WHERE DB_NAME(database_id) NOT IN ('master', 'tempdb', 'msdb', 'model', 'rdsadmin', 'distribution', 'model_msdb', 'model_replicatedmaster')
+				GROUP BY database_id
+		`,
+		dataModels: &[]struct {
+			database.DataModel
+			IOStalls int `db:"io_stalls" metric_name:"io.stallInMilliseconds" source_type:"gauge"`
+		}{},
+	},
+}
+
 var databaseDiskDefinitionsForAzureSQLDatabase = []*QueryDefinition{
 	{
 		query: `
@@ -193,52 +227,3 @@ var specificDatabaseDefinitionsForAzureSQLDatabase = []*QueryDefinition{
 		}{},
 	},
 }
-
-// EngineSet is a generic struct that acts as a "bucket" for holding
-// the default and Azure-specific implementations for a given resource.
-type EngineSet[T any] struct {
-	Default          T
-	AzureSQLDatabase T
-}
-
-// Select returns the correct implementation from the set based on the engine edition.
-func (s EngineSet[T]) Select(engineEdition int) T {
-	if engineEdition == database.AzureSQLDatabaseEngineEditionNumber {
-		return s.AzureSQLDatabase
-	}
-	return s.Default
-}
-
-// QueryDefinitionType is a custom type for identifying different query sets.
-type QueryDefinitionType int
-
-// Enum of the different query definition types.
-const (
-	StandardQueries = iota
-	BufferQueries
-	SpecificQueries
-)
-
-var queryDefinitionSets = map[QueryDefinitionType]EngineSet[[]*QueryDefinition]{
-	StandardQueries: {
-		Default:          databaseDefinitions,
-		AzureSQLDatabase: databaseDefinitionsForAzureSQLDatabase,
-	},
-	BufferQueries: {
-		Default:          databaseBufferDefinitions,
-		AzureSQLDatabase: databaseBufferDefinitionsForAzureSQLDatabase,
-	},
-	SpecificQueries: {
-		Default:          specificDatabaseDefinitions,
-		AzureSQLDatabase: specificDatabaseDefinitionsForAzureSQLDatabase,
-	},
-}
-
-func GetQueryDefinitions(defType QueryDefinitionType, engineEdition int) []*QueryDefinition {
-	definitionSet, ok := queryDefinitionSets[defType]
-	if !ok {
-		log.Error("Error: Invalid query definition type provided: %d", defType)
-		return nil
-	}
-	return definitionSet.Select(engineEdition)
-}

src/metrics/instance_metric_definitions.go

@@ -122,6 +122,9 @@ var instanceDefinitions = []*QueryDefinition{
 			InstanceActiveConnections *int64 `db:"instance_active_connections" metric_name:"activeConnections" source_type:"gauge"`
 		}{},
 	},
+}
+
+var instanceMemoryDefinitions = []*QueryDefinition{
 	{
 		query: `SELECT
 		Max(sys_mem.total_physical_memory_kb * 1024.0) AS total_physical_memory,
@@ -138,6 +141,25 @@ var instanceDefinitions = []*QueryDefinition{
 	},
 }
 
+var instanceMemoryDefinitionsForAzureSQLManagedInstance = []*QueryDefinition{
+	{
+		query: `
+			SELECT
+				Max(sys_mem.total_physical_memory_kb * 1024.0) AS total_physical_memory,
+				Max(sys_mem.available_physical_memory_kb * 1024.0) AS available_physical_memory,
+				(Max(proc_mem.physical_memory_in_use_kb) / (Max(sys_mem.total_physical_memory_kb) * 1.0)) * 100 AS memory_utilization
+			FROM sys.dm_os_process_memory proc_mem,
+				sys.dm_os_sys_memory sys_mem,
+				sys.dm_os_performance_counters perf_count WHERE object_name LIKE '%:Memory Manager%'
+		`,
+		dataModels: &[]struct {
+			TotalPhysicalMemory     *float64 `db:"total_physical_memory" metric_name:"memoryTotal" source_type:"gauge"`
+			AvailablePhysicalMemory *float64 `db:"available_physical_memory" metric_name:"memoryAvailable" source_type:"gauge"`
+			MemoryUtilization       *float64 `db:"memory_utilization" metric_name:"memoryUtilization" source_type:"gauge"`
+		}{},
+	},
+}
+
 var instanceBufferDefinitions = []*QueryDefinition{
 	{
 		query: ` SELECT

src/metrics/metric_definition_sets.go

@@ -0,0 +1,69 @@
+package metrics
+
+import (
+	"github.com/newrelic/infra-integrations-sdk/v3/log"
+	"github.com/newrelic/nri-mssql/src/database"
+)
+
+// EngineSet is a generic struct that acts as a "bucket" for holding
+// the default and Azure-specific implementations for a given resource.
+type EngineSet[T any] struct {
+	Default                 T
+	AzureSQLDatabase        T
+	AzureSQLManagedInstance T
+}
+
+// Select returns the correct implementation from the set based on the engine edition.
+func (s EngineSet[T]) Select(engineEdition int) T {
+	switch engineEdition {
+	case database.AzureSQLDatabaseEngineEditionNumber:
+		return s.AzureSQLDatabase
+	case database.AzureSQLManagedInstanceEngineEditionNumber:
+		return s.AzureSQLManagedInstance
+	default:
+		return s.Default
+	}
+}
+
+// QueryDefinitionType is a custom type for identifying different query sets.
+type QueryDefinitionType int
+
+// Enum of the different query definition types.
+const (
+	StandardQueries = iota
+	BufferQueries
+	SpecificQueries
+	MemoryQueries
+)
+
+var queryDefinitionSets = map[QueryDefinitionType]EngineSet[[]*QueryDefinition]{
+	StandardQueries: {
+		Default:                 databaseDefinitions,
+		AzureSQLDatabase:        databaseDefinitionsForAzureSQLDatabase,
+		AzureSQLManagedInstance: databaseDefinitionsForAzureSQLManagedInstance,
+	},
+	BufferQueries: {
+		Default:                 databaseBufferDefinitions,
+		AzureSQLDatabase:        databaseBufferDefinitionsForAzureSQLDatabase,
+		AzureSQLManagedInstance: databaseBufferDefinitions,
+	},
+	SpecificQueries: {
+		Default:                 specificDatabaseDefinitions,
+		AzureSQLDatabase:        specificDatabaseDefinitionsForAzureSQLDatabase,
+		AzureSQLManagedInstance: specificDatabaseDefinitions,
+	},
+	MemoryQueries: {
+		Default:                 instanceMemoryDefinitions,
+		AzureSQLDatabase:        []*QueryDefinition{},
+		AzureSQLManagedInstance: instanceMemoryDefinitionsForAzureSQLManagedInstance,
+	},
+}
+
+func GetQueryDefinitions(defType QueryDefinitionType, engineEdition int) []*QueryDefinition {
+	definitionSet, ok := queryDefinitionSets[defType]
+	if !ok {
+		log.Error("Error: Invalid query definition type provided: %d", defType)
+		return nil
+	}
+	return definitionSet.Select(engineEdition)
+}

src/metrics/metrics.go

@@ -61,6 +61,7 @@ func PopulateInstanceMetrics(instanceEntity *integration.Entity, connection *con
 	)
 
 	collectionList := instanceDefinitions
+	collectionList = append(collectionList, GetQueryDefinitions(MemoryQueries, engineEdition)...)
 	if arguments.EnableBufferMetrics {
 		collectionList = append(collectionList, instanceBufferDefinitions...)
 	}
@@ -337,8 +338,9 @@ type databaseMetricsProcessor func(*integration.Integration, string, *connection
 
 // Bucket for processor functions
 var processorFunctionSet = EngineSet[databaseMetricsProcessor]{
-	Default:          processDefaultDBMetrics,
-	AzureSQLDatabase: processAzureSQLDatabaseMetrics,
+	Default:                 processDefaultDBMetrics,
+	AzureSQLDatabase:        processAzureSQLDatabaseMetrics,
+	AzureSQLManagedInstance: processDefaultDBMetrics,
 }
 
 // PopulateDatabaseMetrics collects per-database metrics
@@ -369,9 +371,9 @@ func PopulateDatabaseMetrics(i *integration.Integration, instanceName string, co
 }
 
 // processDefaultDBMetrics handles metric collection for a standard SQL Server instance.
-func processDefaultDBMetrics(i *integration.Integration, instanceName string, connection *connection.SQLConnection, arguments args.ArgumentList, dbSetLookup database.DBMetricSetLookup, _ int, modelChan chan<- interface{}) {
+func processDefaultDBMetrics(i *integration.Integration, instanceName string, connection *connection.SQLConnection, arguments args.ArgumentList, dbSetLookup database.DBMetricSetLookup, engineEdition int, modelChan chan<- interface{}) {
 	// run queries that are not specific to a database
-	processGeneralDBDefinitions(connection, modelChan)
+	processDBDefinitions(connection, GetQueryDefinitions(StandardQueries, engineEdition), modelChan)
 
 	// run queries that are not specific to a database
 	if arguments.EnableBufferMetrics {
@@ -384,6 +386,22 @@ func processDefaultDBMetrics(i *integration.Integration, instanceName string, co
 	}
 }
 
+// processAzureSQLDatabaseMetrics handles metric collection for Azure SQL Database concurrently.
+// It dispatches the work of processing each database to a worker goroutine.
+func processAzureSQLDatabaseMetrics(i *integration.Integration, instanceName string, _ *connection.SQLConnection, arguments args.ArgumentList, dbSetLookup database.DBMetricSetLookup, engineEdition int, modelChan chan<- interface{}) {
+	databaseNames := dbSetLookup.GetDBNames()
+
+	dbChan := make(chan struct{}, maxConcurrentWorkers)
+	var waitGroup sync.WaitGroup
+
+	for _, dbName := range databaseNames {
+		waitGroup.Add(1)
+		dbChan <- struct{}{}
+		go processSingleAzureDB(&waitGroup, dbChan, dbName, arguments, engineEdition, modelChan)
+	}
+	waitGroup.Wait()
+}
+
 func processSingleAzureDB(wg *sync.WaitGroup, dbChan chan struct{}, dbName string, arguments args.ArgumentList, engineEdition int, modelChan chan<- interface{}) {
 	defer wg.Done()
 	defer func() { <-dbChan }()
@@ -445,34 +463,12 @@ func processMemoryDBDefinitions(con *connection.SQLConnection, dbName string, mo
 	}
 }
 
-// processAzureSQLDatabaseMetrics handles metric collection for Azure SQL Database concurrently.
-// It dispatches the work of processing each database to a worker goroutine.
-func processAzureSQLDatabaseMetrics(i *integration.Integration, instanceName string, _ *connection.SQLConnection, arguments args.ArgumentList, dbSetLookup database.DBMetricSetLookup, engineEdition int, modelChan chan<- interface{}) {
-	databaseNames := dbSetLookup.GetDBNames()
-
-	dbChan := make(chan struct{}, maxConcurrentWorkers)
-	var waitGroup sync.WaitGroup
-
-	for _, dbName := range databaseNames {
-		waitGroup.Add(1)
-		dbChan <- struct{}{}
-		go processSingleAzureDB(&waitGroup, dbChan, dbName, arguments, engineEdition, modelChan)
-	}
-	waitGroup.Wait()
-}
-
 func processDBDefinitions(con *connection.SQLConnection, definitions []*QueryDefinition, modelChan chan<- interface{}) {
 	for _, queryDef := range definitions {
 		makeDBQuery(con, queryDef.GetQuery(), queryDef.GetDataModels(), modelChan)
 	}
 }
 
-func processGeneralDBDefinitions(con *connection.SQLConnection, modelChan chan<- interface{}) {
-	for _, queryDef := range databaseDefinitions {
-		makeDBQuery(con, queryDef.GetQuery(), queryDef.GetDataModels(), modelChan)
-	}
-}
-
 func processDBBufferDefinitions(con *connection.SQLConnection, modelChan chan<- interface{}) {
 	for _, queryDef := range databaseBufferDefinitions {
 		makeDBQuery(con, queryDef.GetQuery(), queryDef.GetDataModels(), modelChan)