mssql: expose server version info (#1741)

Signed-off-by: Jan-Otto Kröpke <mail@jkroepke.de>

internal/collector/mssql/mssql.go

@@ -7,15 +7,20 @@ import (
 	"fmt"
 	"log/slog"
 	"sort"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
+	"unsafe"
 
+	"github.com/Microsoft/go-winio/pkg/process"
 	"github.com/alecthomas/kingpin/v2"
+	"github.com/prometheus-community/windows_exporter/internal/headers/iphlpapi"
 	"github.com/prometheus-community/windows_exporter/internal/mi"
 	"github.com/prometheus-community/windows_exporter/internal/perfdata"
 	"github.com/prometheus-community/windows_exporter/internal/types"
 	"github.com/prometheus/client_golang/prometheus"
+	"golang.org/x/sys/windows"
 	"golang.org/x/sys/windows/registry"
 )
 
@@ -38,6 +43,7 @@ const (
 
 type Config struct {
 	CollectorsEnabled []string `yaml:"collectors_enabled"`
+	Port              uint16   `yaml:"port"`
 }
 
 var ConfigDefaults = Config{
@@ -55,6 +61,7 @@ var ConfigDefaults = Config{
 		subCollectorTransactions,
 		subCollectorWaitStats,
 	},
+	Port: 1433,
 }
 
 // A Collector is a Prometheus Collector for various WMI Win32_PerfRawData_MSSQLSERVER_* metrics.
@@ -67,9 +74,13 @@ type Collector struct {
 	collectorFns   []func(ch chan<- prometheus.Metric) error
 	closeFns       []func()
 
+	fileVersion    string
+	productVersion string
+
 	// meta
 	mssqlScrapeDurationDesc *prometheus.Desc
 	mssqlScrapeSuccessDesc  *prometheus.Desc
+	mssqlInfoDesc           *prometheus.Desc
 
 	collectorAccessMethods
 	collectorAvailabilityReplica
@@ -96,6 +107,10 @@ func New(config *Config) *Collector {
 		config.CollectorsEnabled = ConfigDefaults.CollectorsEnabled
 	}
 
+	if config.Port == 0 {
+		config.Port = ConfigDefaults.Port
+	}
+
 	c := &Collector{
 		config: *config,
 	}
@@ -115,6 +130,11 @@ func NewWithFlags(app *kingpin.Application) *Collector {
 		"Comma-separated list of collectors to use.",
 	).Default(strings.Join(c.config.CollectorsEnabled, ",")).StringVar(&collectorsEnabled)
 
+	app.Flag(
+		"collector.mssql.port",
+		"Port of MSSQL server used for windows_mssql_info metric.",
+	).Default(strconv.FormatUint(uint64(c.config.Port), 10)).Uint16Var(&c.config.Port)
+
 	app.Action(func(*kingpin.ParseContext) error {
 		c.config.CollectorsEnabled = strings.Split(collectorsEnabled, ",")
 
@@ -140,6 +160,17 @@ func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
 	c.logger = logger.With(slog.String("collector", Name))
 	c.mssqlInstances = c.getMSSQLInstances()
 
+	fileVersion, productVersion, err := c.getMSSQLServerVersion(c.config.Port)
+	if err != nil {
+		logger.Warn("Failed to get MSSQL server version",
+			slog.Any("err", err),
+			slog.String("collector", Name),
+		)
+	}
+
+	c.fileVersion = fileVersion
+	c.productVersion = productVersion
+
 	subCollectors := map[string]struct {
 		build   func() error
 		collect func(ch chan<- prometheus.Metric) error
@@ -209,7 +240,6 @@ func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
 
 	c.collectorFns = make([]func(ch chan<- prometheus.Metric) error, 0, len(c.config.CollectorsEnabled))
 	c.closeFns = make([]func(), 0, len(c.config.CollectorsEnabled))
-
 	// Result must order, to prevent test failures.
 	sort.Strings(c.config.CollectorsEnabled)
 
@@ -227,6 +257,13 @@ func (c *Collector) Build(logger *slog.Logger, _ *mi.Session) error {
 	}
 
 	// meta
+	c.mssqlInfoDesc = prometheus.NewDesc(
+		prometheus.BuildFQName(types.Namespace, Name, "info"),
+		"mssql server information",
+		[]string{"file_version", "version"},
+		nil,
+	)
+
 	c.mssqlScrapeDurationDesc = prometheus.NewDesc(
 		prometheus.BuildFQName(types.Namespace, Name, "collector_duration_seconds"),
 		"windows_exporter: Duration of an mssql child collection.",
@@ -379,3 +416,68 @@ func (c *Collector) collect(
 
 	return errors.Join(errs...)
 }
+
+// getMSSQLServerVersion get the version of the SQL Server instance by
+// reading the version information from the process running the SQL Server instance port.
+func (c *Collector) getMSSQLServerVersion(port uint16) (string, string, error) {
+	pid, err := iphlpapi.GetOwnerPIDOfTCPPort(windows.AF_INET, port)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to get the PID of the process running on port 1433: %w", err)
+	}
+
+	hProcess, err := windows.OpenProcess(windows.PROCESS_QUERY_LIMITED_INFORMATION, false, pid)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to open the process with PID %d: %w", pid, err)
+	}
+
+	defer windows.CloseHandle(hProcess) //nolint:errcheck
+
+	processFilePath, err := process.QueryFullProcessImageName(hProcess, process.ImageNameFormatWin32Path)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to query the full path of the process with PID %d: %w", pid, err)
+	}
+
+	// Load the file version information
+	size, err := windows.GetFileVersionInfoSize(processFilePath, nil)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to get the size of the file version information: %w", err)
+	}
+
+	fileVersionInfo := make([]byte, size)
+
+	err = windows.GetFileVersionInfo(processFilePath, 0, size, unsafe.Pointer(&fileVersionInfo[0]))
+	if err != nil {
+		return "", "", fmt.Errorf("failed to get the file version information: %w", err)
+	}
+
+	var (
+		verData *byte
+		verSize uint32
+	)
+
+	err = windows.VerQueryValue(
+		unsafe.Pointer(&fileVersionInfo[0]),
+		`\StringFileInfo\040904b0\ProductVersion`,
+		unsafe.Pointer(&verData),
+		&verSize,
+	)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to query the product version: %w", err)
+	}
+
+	productVersion := windows.UTF16ToString((*[1 << 16]uint16)(unsafe.Pointer(verData))[:verSize])
+
+	err = windows.VerQueryValue(
+		unsafe.Pointer(&fileVersionInfo[0]),
+		`\StringFileInfo\040904b0\FileVersion`,
+		unsafe.Pointer(&verData),
+		&verSize,
+	)
+	if err != nil {
+		return "", "", fmt.Errorf("failed to query the file version: %w", err)
+	}
+
+	fileVersion := windows.UTF16ToString((*[1 << 16]uint16)(unsafe.Pointer(verData))[:verSize])
+
+	return fileVersion, productVersion, nil
+}

internal/headers/iphlpapi/const.go

@@ -3,6 +3,6 @@
 package iphlpapi
 
 const (
-	TCPTableClass  uint32 = 5
-	TCP6TableClass uint32 = 5
+	TCPTableOwnerPIDAll      uint32 = 5
+	TCPTableOwnerPIDListener uint32 = 3
 )

internal/headers/iphlpapi/iphlpapi.go

@@ -3,6 +3,7 @@
 package iphlpapi
 
 import (
+	"encoding/binary"
 	"fmt"
 	"unsafe"
 
@@ -15,65 +16,99 @@ var (
 )
 
 func GetTCPConnectionStates(family uint32) (map[MIB_TCP_STATE]uint32, error) {
+	stateCounts := make(map[MIB_TCP_STATE]uint32)
+
+	switch family {
+	case windows.AF_INET:
+		table, err := getExtendedTcpTable[MIB_TCPROW_OWNER_PID](family, TCPTableOwnerPIDAll)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, row := range table {
+			stateCounts[row.dwState]++
+		}
+
+		return stateCounts, nil
+	case windows.AF_INET6:
+		table, err := getExtendedTcpTable[MIB_TCP6ROW_OWNER_PID](family, TCPTableOwnerPIDAll)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, row := range table {
+			stateCounts[row.dwState]++
+		}
+
+		return stateCounts, nil
+	default:
+		return nil, fmt.Errorf("unsupported address family %d", family)
+	}
+}
+
+func GetOwnerPIDOfTCPPort(family uint32, tcpPort uint16) (uint32, error) {
+	switch family {
+	case windows.AF_INET:
+		table, err := getExtendedTcpTable[MIB_TCPROW_OWNER_PID](family, TCPTableOwnerPIDListener)
+		if err != nil {
+			return 0, err
+		}
+
+		for _, row := range table {
+			if row.dwLocalPort.uint16() == tcpPort {
+				return row.dwOwningPid, nil
+			}
+		}
+
+		return 0, fmt.Errorf("no process found for port %d", tcpPort)
+	case windows.AF_INET6:
+		table, err := getExtendedTcpTable[MIB_TCP6ROW_OWNER_PID](family, TCPTableOwnerPIDListener)
+		if err != nil {
+			return 0, err
+		}
+
+		for _, row := range table {
+			if row.dwLocalPort.uint16() == tcpPort {
+				return row.dwOwningPid, nil
+			}
+		}
+
+		return 0, fmt.Errorf("no process found for port %d", tcpPort)
+	default:
+		return 0, fmt.Errorf("unsupported address family %d", family)
+	}
+}
+
+func getExtendedTcpTable[T any](ulAf uint32, tableClass uint32) ([]T, error) {
 	var size uint32
 
-	stateCounts := make(map[MIB_TCP_STATE]uint32)
-	rowSize := uint32(unsafe.Sizeof(MIB_TCPROW_OWNER_PID{}))
-	tableClass := TCPTableClass
+	ret, _, _ := procGetExtendedTcpTable.Call(
+		uintptr(0),
+		uintptr(unsafe.Pointer(&size)),
+		uintptr(0),
+		uintptr(ulAf),
+		uintptr(tableClass),
+		uintptr(0),
+	)
 
-	if family == windows.AF_INET6 {
-		rowSize = uint32(unsafe.Sizeof(MIB_TCP6ROW_OWNER_PID{}))
-		tableClass = TCP6TableClass
-	}
-
-	ret := getExtendedTcpTable(0, &size, true, family, tableClass, 0)
-	if ret != 0 && ret != uintptr(windows.ERROR_INSUFFICIENT_BUFFER) {
+	if ret != uintptr(windows.ERROR_INSUFFICIENT_BUFFER) {
 		return nil, fmt.Errorf("getExtendedTcpTable (size query) failed with code %d", ret)
 	}
 
 	buf := make([]byte, size)
 
-	ret = getExtendedTcpTable(uintptr(unsafe.Pointer(&buf[0])), &size, true, family, tableClass, 0)
+	ret, _, _ = procGetExtendedTcpTable.Call(
+		uintptr(unsafe.Pointer(&buf[0])),
+		uintptr(unsafe.Pointer(&size)),
+		uintptr(0),
+		uintptr(ulAf),
+		uintptr(tableClass),
+		uintptr(0),
+	)
+
 	if ret != 0 {
 		return nil, fmt.Errorf("getExtendedTcpTable (data query) failed with code %d", ret)
 	}
 
-	numEntries := *(*uint32)(unsafe.Pointer(&buf[0]))
-
-	for i := range numEntries {
-		var state MIB_TCP_STATE
-
-		if family == windows.AF_INET6 {
-			row := (*MIB_TCP6ROW_OWNER_PID)(unsafe.Pointer(&buf[4+i*rowSize]))
-			state = row.dwState
-		} else {
-			row := (*MIB_TCPROW_OWNER_PID)(unsafe.Pointer(&buf[4+i*rowSize]))
-			state = row.dwState
-		}
-
-		stateCounts[state]++
-	}
-
-	return stateCounts, nil
-}
-
-func getExtendedTcpTable(pTCPTable uintptr, pdwSize *uint32, bOrder bool, ulAf uint32, tableClass uint32, reserved uint32) uintptr {
-	ret, _, _ := procGetExtendedTcpTable.Call(
-		pTCPTable,
-		uintptr(unsafe.Pointer(pdwSize)),
-		uintptr(boolToInt(bOrder)),
-		uintptr(ulAf),
-		uintptr(tableClass),
-		uintptr(reserved),
-	)
-
-	return ret
-}
-
-func boolToInt(b bool) int {
-	if b {
-		return 1
-	}
-
-	return 0
+	return unsafe.Slice((*T)(unsafe.Pointer(&buf[4])), binary.LittleEndian.Uint32(buf)), nil
 }

internal/headers/iphlpapi/iphlpapi_test.go

@@ -0,0 +1,34 @@
+package iphlpapi_test
+
+import (
+	"net"
+	"os"
+	"testing"
+
+	"github.com/prometheus-community/windows_exporter/internal/headers/iphlpapi"
+	"github.com/stretchr/testify/require"
+	"golang.org/x/sys/windows"
+)
+
+func TestGetTCPConnectionStates(t *testing.T) {
+	t.Parallel()
+
+	pid, err := iphlpapi.GetTCPConnectionStates(windows.AF_INET)
+	require.NoError(t, err)
+	require.NotEmpty(t, pid)
+}
+
+func TestGetOwnerPIDOfTCPPort(t *testing.T) {
+	t.Parallel()
+
+	lister, err := net.Listen("tcp", "127.0.0.1:0")
+	require.NoError(t, err)
+
+	t.Cleanup(func() {
+		require.NoError(t, lister.Close())
+	})
+
+	pid, err := iphlpapi.GetOwnerPIDOfTCPPort(windows.AF_INET, uint16(lister.Addr().(*net.TCPAddr).Port))
+	require.NoError(t, err)
+	require.EqualValues(t, os.Getpid(), pid)
+}

internal/headers/iphlpapi/types.go

@@ -2,28 +2,35 @@
 
 package iphlpapi
 
-import "fmt"
+import (
+	"encoding/binary"
+	"fmt"
+)
 
 // MIB_TCPROW_OWNER_PID structure for IPv4.
 // https://learn.microsoft.com/en-us/windows/win32/api/tcpmib/ns-tcpmib-mib_tcprow_owner_pid
+//
+//nolint:unused
 type MIB_TCPROW_OWNER_PID struct {
 	dwState      MIB_TCP_STATE
-	dwLocalAddr  uint32
-	dwLocalPort  uint32
-	dwRemoteAddr uint32
-	dwRemotePort uint32
+	dwLocalAddr  BigEndianUint32
+	dwLocalPort  BigEndianUint32
+	dwRemoteAddr BigEndianUint32
+	dwRemotePort BigEndianUint32
 	dwOwningPid  uint32
 }
 
 // MIB_TCP6ROW_OWNER_PID structure for IPv6.
 // https://learn.microsoft.com/en-us/windows/win32/api/tcpmib/ns-tcpmib-mib_tcp6row_owner_pid
+//
+//nolint:unused
 type MIB_TCP6ROW_OWNER_PID struct {
 	ucLocalAddr     [16]byte
 	dwLocalScopeId  uint32
-	dwLocalPort     uint32
+	dwLocalPort     BigEndianUint32
 	ucRemoteAddr    [16]byte
 	dwRemoteScopeId uint32
-	dwRemotePort    uint32
+	dwRemotePort    BigEndianUint32
 	dwState         MIB_TCP_STATE
 	dwOwningPid     uint32
 }
@@ -76,3 +83,12 @@ func (state MIB_TCP_STATE) String() string {
 		return fmt.Sprintf("UNKNOWN_%d", state)
 	}
 }
+
+type BigEndianUint32 uint32
+
+func (b BigEndianUint32) uint16() uint16 {
+	data := make([]byte, 2)
+	binary.BigEndian.PutUint16(data, uint16(b))
+
+	return binary.LittleEndian.Uint16(data)
+}