windows_exporter/collector/mssql.go

// +build windows

package collector

import (
	"errors"
	"fmt"
	"os"
	"strings"
	"sync"
	"time"

	"github.com/StackExchange/wmi"
	"github.com/prometheus/client_golang/prometheus"
	"github.com/prometheus/common/log"
	"golang.org/x/sys/windows/registry"
	"gopkg.in/alecthomas/kingpin.v2"
)

var (
	mssqlEnabledCollectors = kingpin.Flag(
		"collectors.mssql.classes-enabled",
		"Comma-separated list of mssql WMI classes to use.").
		Default(mssqlAvailableClassCollectors()).String()

	mssqlPrintCollectors = kingpin.Flag(
		"collectors.mssql.class-print",
		"If true, print available mssql WMI classes and exit.  Only displays if the mssql collector is enabled.",
	).Bool()
)

type mssqlInstancesType map[string]string

func getMSSQLInstances() mssqlInstancesType {
	sqlInstances := make(mssqlInstancesType)

	// in case querying the registry fails, return the default instance
	sqlDefaultInstance := make(mssqlInstancesType)
	sqlDefaultInstance["MSSQLSERVER"] = ""

	regkey := `Software\Microsoft\Microsoft SQL Server\Instance Names\SQL`
	k, err := registry.OpenKey(registry.LOCAL_MACHINE, regkey, registry.QUERY_VALUE)
	if err != nil {
		log.Warn("Couldn't open registry to determine SQL instances:", err)
		return sqlDefaultInstance
	}
	defer func() {
		err = k.Close()
		if err != nil {
			log.Warnf("Failed to close registry key: %v", err)
		}
	}()

	instanceNames, err := k.ReadValueNames(0)
	if err != nil {
		log.Warnf("Can't ReadSubKeyNames %#v", err)
		return sqlDefaultInstance
	}

	for _, instanceName := range instanceNames {
		if instanceVersion, _, err := k.GetStringValue(instanceName); err == nil {
			sqlInstances[instanceName] = instanceVersion
		}
	}

	log.Debugf("Detected MSSQL Instances: %#v\n", sqlInstances)

	return sqlInstances
}

// mssqlBuildWMIInstanceClass - a helper function to build the correct WMI class name
// if default instance, class looks like `Win32_PerfRawData_MSSQLSERVER_SQLServerGeneralStatistics`
// if instance is 'SQLA` class looks like `Win32_PerfRawData_MSSQLSQLA_MSSQLSQLAGeneralStatistics`
func mssqlBuildWMIInstanceClass(suffix string, instance string) string {
	instancePart := "MSSQLSERVER_SQLServer"
	if instance != "MSSQLSERVER" {
		// Instance names can contain some special characters, which are not supported in the WMI class name.
		// We strip those out.
		cleanedName := strings.Map(func(r rune) rune {
			if r == '_' || r == '$' || r == '#' {
				return -1
			}
			return r
		}, instance)
		instancePart = fmt.Sprintf("MSSQL%s_MSSQL%s", cleanedName, cleanedName)
	}

	return fmt.Sprintf("Win32_PerfRawData_%s%s", instancePart, suffix)
}

type mssqlCollectorsMap map[string]mssqlCollectorFunc

func mssqlAvailableClassCollectors() string {
	return "accessmethods,availreplica,bufman,databases,dbreplica,genstats,locks,memmgr,sqlstats,sqlerrors,transactions"
}

func (c *MSSQLCollector) getMSSQLCollectors() mssqlCollectorsMap {
	mssqlCollectors := make(mssqlCollectorsMap)
	mssqlCollectors["accessmethods"] = c.collectAccessMethods
	mssqlCollectors["availreplica"] = c.collectAvailabilityReplica
	mssqlCollectors["bufman"] = c.collectBufferManager
	mssqlCollectors["databases"] = c.collectDatabases
	mssqlCollectors["dbreplica"] = c.collectDatabaseReplica
	mssqlCollectors["genstats"] = c.collectGeneralStatistics
	mssqlCollectors["locks"] = c.collectLocks
	mssqlCollectors["memmgr"] = c.collectMemoryManager
	mssqlCollectors["sqlstats"] = c.collectSQLStats
	mssqlCollectors["sqlerrors"] = c.collectSQLErrors
	mssqlCollectors["transactions"] = c.collectTransactions

	return mssqlCollectors
}

func mssqlExpandEnabledCollectors(enabled string) []string {
	separated := strings.Split(enabled, ",")
	unique := map[string]bool{}
	for _, s := range separated {
		if s != "" {
			unique[s] = true
		}
	}
	result := make([]string, 0, len(unique))
	for s := range unique {
		result = append(result, s)
	}
	return result
}

func init() {
	Factories["mssql"] = NewMSSQLCollector
}

// A MSSQLCollector is a Prometheus collector for various WMI Win32_PerfRawData_MSSQLSERVER_* metrics
type MSSQLCollector struct {
	// meta
	mssqlScrapeDurationDesc *prometheus.Desc
	mssqlScrapeSuccessDesc  *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerAccessMethods
	AccessMethodsAUcleanupbatches             *prometheus.Desc
	AccessMethodsAUcleanups                   *prometheus.Desc
	AccessMethodsByreferenceLobCreateCount    *prometheus.Desc
	AccessMethodsByreferenceLobUseCount       *prometheus.Desc
	AccessMethodsCountLobReadahead            *prometheus.Desc
	AccessMethodsCountPullInRow               *prometheus.Desc
	AccessMethodsCountPushOffRow              *prometheus.Desc
	AccessMethodsDeferreddroppedAUs           *prometheus.Desc
	AccessMethodsDeferredDroppedrowsets       *prometheus.Desc
	AccessMethodsDroppedrowsetcleanups        *prometheus.Desc
	AccessMethodsDroppedrowsetsskipped        *prometheus.Desc
	AccessMethodsExtentDeallocations          *prometheus.Desc
	AccessMethodsExtentsAllocated             *prometheus.Desc
	AccessMethodsFailedAUcleanupbatches       *prometheus.Desc
	AccessMethodsFailedleafpagecookie         *prometheus.Desc
	AccessMethodsFailedtreepagecookie         *prometheus.Desc
	AccessMethodsForwardedRecords             *prometheus.Desc
	AccessMethodsFreeSpacePageFetches         *prometheus.Desc
	AccessMethodsFreeSpaceScans               *prometheus.Desc
	AccessMethodsFullScans                    *prometheus.Desc
	AccessMethodsIndexSearches                *prometheus.Desc
	AccessMethodsInSysXactwaits               *prometheus.Desc
	AccessMethodsLobHandleCreateCount         *prometheus.Desc
	AccessMethodsLobHandleDestroyCount        *prometheus.Desc
	AccessMethodsLobSSProviderCreateCount     *prometheus.Desc
	AccessMethodsLobSSProviderDestroyCount    *prometheus.Desc
	AccessMethodsLobSSProviderTruncationCount *prometheus.Desc
	AccessMethodsMixedpageallocations         *prometheus.Desc
	AccessMethodsPagecompressionattempts      *prometheus.Desc
	AccessMethodsPageDeallocations            *prometheus.Desc
	AccessMethodsPagesAllocated               *prometheus.Desc
	AccessMethodsPagescompressed              *prometheus.Desc
	AccessMethodsPageSplits                   *prometheus.Desc
	AccessMethodsProbeScans                   *prometheus.Desc
	AccessMethodsRangeScans                   *prometheus.Desc
	AccessMethodsScanPointRevalidations       *prometheus.Desc
	AccessMethodsSkippedGhostedRecords        *prometheus.Desc
	AccessMethodsTableLockEscalations         *prometheus.Desc
	AccessMethodsUsedleafpagecookie           *prometheus.Desc
	AccessMethodsUsedtreepagecookie           *prometheus.Desc
	AccessMethodsWorkfilesCreated             *prometheus.Desc
	AccessMethodsWorktablesCreated            *prometheus.Desc
	AccessMethodsWorktablesFromCacheRatio     *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerAvailabilityReplica
	AvailReplicaBytesReceivedfromReplica *prometheus.Desc
	AvailReplicaBytesSenttoReplica       *prometheus.Desc
	AvailReplicaBytesSenttoTransport     *prometheus.Desc
	AvailReplicaFlowControl              *prometheus.Desc
	AvailReplicaFlowControlTimems        *prometheus.Desc
	AvailReplicaReceivesfromReplica      *prometheus.Desc
	AvailReplicaResentMessages           *prometheus.Desc
	AvailReplicaSendstoReplica           *prometheus.Desc
	AvailReplicaSendstoTransport         *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerBufferManager
	BufManBackgroundwriterpages         *prometheus.Desc
	BufManBuffercachehitratio           *prometheus.Desc
	BufManCheckpointpages               *prometheus.Desc
	BufManDatabasepages                 *prometheus.Desc
	BufManExtensionallocatedpages       *prometheus.Desc
	BufManExtensionfreepages            *prometheus.Desc
	BufManExtensioninuseaspercentage    *prometheus.Desc
	BufManExtensionoutstandingIOcounter *prometheus.Desc
	BufManExtensionpageevictions        *prometheus.Desc
	BufManExtensionpagereads            *prometheus.Desc
	BufManExtensionpageunreferencedtime *prometheus.Desc
	BufManExtensionpagewrites           *prometheus.Desc
	BufManFreeliststalls                *prometheus.Desc
	BufManIntegralControllerSlope       *prometheus.Desc
	BufManLazywrites                    *prometheus.Desc
	BufManPagelifeexpectancy            *prometheus.Desc
	BufManPagelookups                   *prometheus.Desc
	BufManPagereads                     *prometheus.Desc
	BufManPagewrites                    *prometheus.Desc
	BufManReadaheadpages                *prometheus.Desc
	BufManReadaheadtime                 *prometheus.Desc
	BufManTargetpages                   *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerDatabaseReplica
	DBReplicaDatabaseFlowControlDelay  *prometheus.Desc
	DBReplicaDatabaseFlowControls      *prometheus.Desc
	DBReplicaFileBytesReceived         *prometheus.Desc
	DBReplicaGroupCommits              *prometheus.Desc
	DBReplicaGroupCommitTime           *prometheus.Desc
	DBReplicaLogApplyPendingQueue      *prometheus.Desc
	DBReplicaLogApplyReadyQueue        *prometheus.Desc
	DBReplicaLogBytesCompressed        *prometheus.Desc
	DBReplicaLogBytesDecompressed      *prometheus.Desc
	DBReplicaLogBytesReceived          *prometheus.Desc
	DBReplicaLogCompressionCachehits   *prometheus.Desc
	DBReplicaLogCompressionCachemisses *prometheus.Desc
	DBReplicaLogCompressions           *prometheus.Desc
	DBReplicaLogDecompressions         *prometheus.Desc
	DBReplicaLogremainingforundo       *prometheus.Desc
	DBReplicaLogSendQueue              *prometheus.Desc
	DBReplicaMirroredWriteTransactions *prometheus.Desc
	DBReplicaRecoveryQueue             *prometheus.Desc
	DBReplicaRedoblocked               *prometheus.Desc
	DBReplicaRedoBytesRemaining        *prometheus.Desc
	DBReplicaRedoneBytes               *prometheus.Desc
	DBReplicaRedones                   *prometheus.Desc
	DBReplicaTotalLogrequiringundo     *prometheus.Desc
	DBReplicaTransactionDelay          *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerDatabases
	DatabasesActiveTransactions              *prometheus.Desc
	DatabasesBackupPerRestoreThroughput      *prometheus.Desc
	DatabasesBulkCopyRows                    *prometheus.Desc
	DatabasesBulkCopyThroughput              *prometheus.Desc
	DatabasesCommittableentries              *prometheus.Desc
	DatabasesDataFilesSizeKB                 *prometheus.Desc
	DatabasesDBCCLogicalScanBytes            *prometheus.Desc
	DatabasesGroupCommitTime                 *prometheus.Desc
	DatabasesLogBytesFlushed                 *prometheus.Desc
	DatabasesLogCacheHitRatio                *prometheus.Desc
	DatabasesLogCacheReads                   *prometheus.Desc
	DatabasesLogFilesSizeKB                  *prometheus.Desc
	DatabasesLogFilesUsedSizeKB              *prometheus.Desc
	DatabasesLogFlushes                      *prometheus.Desc
	DatabasesLogFlushWaits                   *prometheus.Desc
	DatabasesLogFlushWaitTime                *prometheus.Desc
	DatabasesLogFlushWriteTimems             *prometheus.Desc
	DatabasesLogGrowths                      *prometheus.Desc
	DatabasesLogPoolCacheMisses              *prometheus.Desc
	DatabasesLogPoolDiskReads                *prometheus.Desc
	DatabasesLogPoolHashDeletes              *prometheus.Desc
	DatabasesLogPoolHashInserts              *prometheus.Desc
	DatabasesLogPoolInvalidHashEntry         *prometheus.Desc
	DatabasesLogPoolLogScanPushes            *prometheus.Desc
	DatabasesLogPoolLogWriterPushes          *prometheus.Desc
	DatabasesLogPoolPushEmptyFreePool        *prometheus.Desc
	DatabasesLogPoolPushLowMemory            *prometheus.Desc
	DatabasesLogPoolPushNoFreeBuffer         *prometheus.Desc
	DatabasesLogPoolReqBehindTrunc           *prometheus.Desc
	DatabasesLogPoolRequestsOldVLF           *prometheus.Desc
	DatabasesLogPoolRequests                 *prometheus.Desc
	DatabasesLogPoolTotalActiveLogSize       *prometheus.Desc
	DatabasesLogPoolTotalSharedPoolSize      *prometheus.Desc
	DatabasesLogShrinks                      *prometheus.Desc
	DatabasesLogTruncations                  *prometheus.Desc
	DatabasesPercentLogUsed                  *prometheus.Desc
	DatabasesReplPendingXacts                *prometheus.Desc
	DatabasesReplTransRate                   *prometheus.Desc
	DatabasesShrinkDataMovementBytes         *prometheus.Desc
	DatabasesTrackedtransactions             *prometheus.Desc
	DatabasesTransactions                    *prometheus.Desc
	DatabasesWriteTransactions               *prometheus.Desc
	DatabasesXTPControllerDLCLatencyPerFetch *prometheus.Desc
	DatabasesXTPControllerDLCPeakLatency     *prometheus.Desc
	DatabasesXTPControllerLogProcessed       *prometheus.Desc
	DatabasesXTPMemoryUsedKB                 *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerGeneralStatistics
	GenStatsActiveTempTables              *prometheus.Desc
	GenStatsConnectionReset               *prometheus.Desc
	GenStatsEventNotificationsDelayedDrop *prometheus.Desc
	GenStatsHTTPAuthenticatedRequests     *prometheus.Desc
	GenStatsLogicalConnections            *prometheus.Desc
	GenStatsLogins                        *prometheus.Desc
	GenStatsLogouts                       *prometheus.Desc
	GenStatsMarsDeadlocks                 *prometheus.Desc
	GenStatsNonatomicyieldrate            *prometheus.Desc
	GenStatsProcessesblocked              *prometheus.Desc
	GenStatsSOAPEmptyRequests             *prometheus.Desc
	GenStatsSOAPMethodInvocations         *prometheus.Desc
	GenStatsSOAPSessionInitiateRequests   *prometheus.Desc
	GenStatsSOAPSessionTerminateRequests  *prometheus.Desc
	GenStatsSOAPSQLRequests               *prometheus.Desc
	GenStatsSOAPWSDLRequests              *prometheus.Desc
	GenStatsSQLTraceIOProviderLockWaits   *prometheus.Desc
	GenStatsTempdbrecoveryunitid          *prometheus.Desc
	GenStatsTempdbrowsetid                *prometheus.Desc
	GenStatsTempTablesCreationRate        *prometheus.Desc
	GenStatsTempTablesForDestruction      *prometheus.Desc
	GenStatsTraceEventNotificationQueue   *prometheus.Desc
	GenStatsTransactions                  *prometheus.Desc
	GenStatsUserConnections               *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerLocks
	LocksAverageWaitTimems    *prometheus.Desc
	LocksLockRequests         *prometheus.Desc
	LocksLockTimeouts         *prometheus.Desc
	LocksLockTimeoutstimeout0 *prometheus.Desc
	LocksLockWaits            *prometheus.Desc
	LocksLockWaitTimems       *prometheus.Desc
	LocksNumberofDeadlocks    *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerMemoryManager
	MemMgrConnectionMemoryKB       *prometheus.Desc
	MemMgrDatabaseCacheMemoryKB    *prometheus.Desc
	MemMgrExternalbenefitofmemory  *prometheus.Desc
	MemMgrFreeMemoryKB             *prometheus.Desc
	MemMgrGrantedWorkspaceMemoryKB *prometheus.Desc
	MemMgrLockBlocks               *prometheus.Desc
	MemMgrLockBlocksAllocated      *prometheus.Desc
	MemMgrLockMemoryKB             *prometheus.Desc
	MemMgrLockOwnerBlocks          *prometheus.Desc
	MemMgrLockOwnerBlocksAllocated *prometheus.Desc
	MemMgrLogPoolMemoryKB          *prometheus.Desc
	MemMgrMaximumWorkspaceMemoryKB *prometheus.Desc
	MemMgrMemoryGrantsOutstanding  *prometheus.Desc
	MemMgrMemoryGrantsPending      *prometheus.Desc
	MemMgrOptimizerMemoryKB        *prometheus.Desc
	MemMgrReservedServerMemoryKB   *prometheus.Desc
	MemMgrSQLCacheMemoryKB         *prometheus.Desc
	MemMgrStolenServerMemoryKB     *prometheus.Desc
	MemMgrTargetServerMemoryKB     *prometheus.Desc
	MemMgrTotalServerMemoryKB      *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerSQLStatistics
	SQLStatsAutoParamAttempts       *prometheus.Desc
	SQLStatsBatchRequests           *prometheus.Desc
	SQLStatsFailedAutoParams        *prometheus.Desc
	SQLStatsForcedParameterizations *prometheus.Desc
	SQLStatsGuidedplanexecutions    *prometheus.Desc
	SQLStatsMisguidedplanexecutions *prometheus.Desc
	SQLStatsSafeAutoParams          *prometheus.Desc
	SQLStatsSQLAttentionrate        *prometheus.Desc
	SQLStatsSQLCompilations         *prometheus.Desc
	SQLStatsSQLReCompilations       *prometheus.Desc
	SQLStatsUnsafeAutoParams        *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerSQLErrors
	SQLErrorsTotal *prometheus.Desc

	// Win32_PerfRawData_{instance}_SQLServerTransactions
	TransactionsTempDbFreeSpaceBytes             *prometheus.Desc
	TransactionsLongestTransactionRunningSeconds *prometheus.Desc
	TransactionsNonSnapshotVersionActiveTotal    *prometheus.Desc
	TransactionsSnapshotActiveTotal              *prometheus.Desc
	TransactionsActiveTotal                      *prometheus.Desc
	TransactionsUpdateConflictsTotal             *prometheus.Desc
	TransactionsUpdateSnapshotActiveTotal        *prometheus.Desc
	TransactionsVersionCleanupRateBytes          *prometheus.Desc
	TransactionsVersionGenerationRateBytes       *prometheus.Desc
	TransactionsVersionStoreSizeBytes            *prometheus.Desc
	TransactionsVersionStoreUnits                *prometheus.Desc
	TransactionsVersionStoreCreationUnits        *prometheus.Desc
	TransactionsVersionStoreTruncationUnits      *prometheus.Desc

	mssqlInstances             mssqlInstancesType
	mssqlCollectors            mssqlCollectorsMap
	mssqlChildCollectorFailure int
}

// NewMSSQLCollector ...
func NewMSSQLCollector() (Collector, error) {

	const subsystem = "mssql"

	mssqlCollector := MSSQLCollector{
		// meta
		mssqlScrapeDurationDesc: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "collector_duration_seconds"),
			"wmi_exporter: Duration of an mssql child collection.",
			[]string{"collector", "instance"},
			nil,
		),
		mssqlScrapeSuccessDesc: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "collector_success"),
			"wmi_exporter: Whether a mssql child collector was successful.",
			[]string{"collector", "instance"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerAccessMethods
		AccessMethodsAUcleanupbatches: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_au_batch_cleanups"),
			"(AccessMethods.AUcleanupbatches)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsAUcleanups: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_au_cleanups"),
			"(AccessMethods.AUcleanups)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsByreferenceLobCreateCount: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_by_reference_lob_creates"),
			"(AccessMethods.ByreferenceLobCreateCount)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsByreferenceLobUseCount: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_by_reference_lob_uses"),
			"(AccessMethods.ByreferenceLobUseCount)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsCountLobReadahead: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_lob_read_aheads"),
			"(AccessMethods.CountLobReadahead)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsCountPullInRow: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_column_value_pulls"),
			"(AccessMethods.CountPullInRow)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsCountPushOffRow: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_column_value_pushes"),
			"(AccessMethods.CountPushOffRow)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsDeferreddroppedAUs: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_deferred_dropped_aus"),
			"(AccessMethods.DeferreddroppedAUs)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsDeferredDroppedrowsets: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_deferred_dropped_rowsets"),
			"(AccessMethods.DeferredDroppedrowsets)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsDroppedrowsetcleanups: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_dropped_rowset_cleanups"),
			"(AccessMethods.Droppedrowsetcleanups)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsDroppedrowsetsskipped: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_dropped_rowset_skips"),
			"(AccessMethods.Droppedrowsetsskipped)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsExtentDeallocations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_extent_deallocations"),
			"(AccessMethods.ExtentDeallocations)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsExtentsAllocated: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_extent_allocations"),
			"(AccessMethods.ExtentsAllocated)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsFailedAUcleanupbatches: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_au_batch_cleanup_failures"),
			"(AccessMethods.FailedAUcleanupbatches)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsFailedleafpagecookie: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_leaf_page_cookie_failures"),
			"(AccessMethods.Failedleafpagecookie)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsFailedtreepagecookie: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_tree_page_cookie_failures"),
			"(AccessMethods.Failedtreepagecookie)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsForwardedRecords: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_forwarded_records"),
			"(AccessMethods.ForwardedRecords)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsFreeSpacePageFetches: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_free_space_page_fetches"),
			"(AccessMethods.FreeSpacePageFetches)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsFreeSpaceScans: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_free_space_scans"),
			"(AccessMethods.FreeSpaceScans)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsFullScans: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_full_scans"),
			"(AccessMethods.FullScans)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsIndexSearches: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_index_searches"),
			"(AccessMethods.IndexSearches)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsInSysXactwaits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_insysxact_waits"),
			"(AccessMethods.InSysXactwaits)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsLobHandleCreateCount: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_lob_handle_creates"),
			"(AccessMethods.LobHandleCreateCount)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsLobHandleDestroyCount: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_lob_handle_destroys"),
			"(AccessMethods.LobHandleDestroyCount)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsLobSSProviderCreateCount: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_lob_ss_provider_creates"),
			"(AccessMethods.LobSSProviderCreateCount)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsLobSSProviderDestroyCount: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_lob_ss_provider_destroys"),
			"(AccessMethods.LobSSProviderDestroyCount)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsLobSSProviderTruncationCount: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_lob_ss_provider_truncations"),
			"(AccessMethods.LobSSProviderTruncationCount)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsMixedpageallocations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_mixed_page_allocations"),
			"(AccessMethods.MixedpageallocationsPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsPagecompressionattempts: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_page_compression_attempts"),
			"(AccessMethods.PagecompressionattemptsPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsPageDeallocations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_page_deallocations"),
			"(AccessMethods.PageDeallocationsPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsPagesAllocated: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_page_allocations"),
			"(AccessMethods.PagesAllocatedPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsPagescompressed: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_page_compressions"),
			"(AccessMethods.PagescompressedPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsPageSplits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_page_splits"),
			"(AccessMethods.PageSplitsPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsProbeScans: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_probe_scans"),
			"(AccessMethods.ProbeScansPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsRangeScans: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_range_scans"),
			"(AccessMethods.RangeScansPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsScanPointRevalidations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_scan_point_revalidations"),
			"(AccessMethods.ScanPointRevalidationsPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsSkippedGhostedRecords: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_ghost_record_skips"),
			"(AccessMethods.SkippedGhostedRecordsPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsTableLockEscalations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_table_lock_escalations"),
			"(AccessMethods.TableLockEscalationsPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsUsedleafpagecookie: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_leaf_page_cookie_uses"),
			"(AccessMethods.Usedleafpagecookie)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsUsedtreepagecookie: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_tree_page_cookie_uses"),
			"(AccessMethods.Usedtreepagecookie)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsWorkfilesCreated: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_workfile_creates"),
			"(AccessMethods.WorkfilesCreatedPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsWorktablesCreated: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_worktables_creates"),
			"(AccessMethods.WorktablesCreatedPersec)",
			[]string{"instance"},
			nil,
		),
		AccessMethodsWorktablesFromCacheRatio: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "accessmethods_worktables_from_cache_ratio"),
			"(AccessMethods.WorktablesFromCacheRatio)",
			[]string{"instance"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerAvailabilityReplica
		AvailReplicaBytesReceivedfromReplica: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_received_from_replica_bytes"),
			"(AvailabilityReplica.BytesReceivedfromReplica)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaBytesSenttoReplica: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_sent_to_replica_bytes"),
			"(AvailabilityReplica.BytesSenttoReplica)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaBytesSenttoTransport: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_sent_to_transport_bytes"),
			"(AvailabilityReplica.BytesSenttoTransport)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaFlowControl: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_initiated_flow_controls"),
			"(AvailabilityReplica.FlowControl)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaFlowControlTimems: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_flow_control_wait_seconds"),
			"(AvailabilityReplica.FlowControlTimems)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaReceivesfromReplica: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_receives_from_replica"),
			"(AvailabilityReplica.ReceivesfromReplica)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaResentMessages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_resent_messages"),
			"(AvailabilityReplica.ResentMessages)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaSendstoReplica: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_sends_to_replica"),
			"(AvailabilityReplica.SendstoReplica)",
			[]string{"instance", "replica"},
			nil,
		),
		AvailReplicaSendstoTransport: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "availreplica_sends_to_transport"),
			"(AvailabilityReplica.SendstoTransport)",
			[]string{"instance", "replica"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerBufferManager
		BufManBackgroundwriterpages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_background_writer_pages"),
			"(BufferManager.Backgroundwriterpages)",
			[]string{"instance"},
			nil,
		),
		BufManBuffercachehitratio: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_buffer_cache_hit_ratio"),
			"(BufferManager.Buffercachehitratio)",
			[]string{"instance"},
			nil,
		),
		BufManCheckpointpages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_checkpoint_pages"),
			"(BufferManager.Checkpointpages)",
			[]string{"instance"},
			nil,
		),
		BufManDatabasepages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_database_pages"),
			"(BufferManager.Databasepages)",
			[]string{"instance"},
			nil,
		),
		BufManExtensionallocatedpages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_allocated_pages"),
			"(BufferManager.Extensionallocatedpages)",
			[]string{"instance"},
			nil,
		),
		BufManExtensionfreepages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_free_pages"),
			"(BufferManager.Extensionfreepages)",
			[]string{"instance"},
			nil,
		),
		BufManExtensioninuseaspercentage: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_in_use_as_percentage"),
			"(BufferManager.Extensioninuseaspercentage)",
			[]string{"instance"},
			nil,
		),
		BufManExtensionoutstandingIOcounter: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_outstanding_io"),
			"(BufferManager.ExtensionoutstandingIOcounter)",
			[]string{"instance"},
			nil,
		),
		BufManExtensionpageevictions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_page_evictions"),
			"(BufferManager.Extensionpageevictions)",
			[]string{"instance"},
			nil,
		),
		BufManExtensionpagereads: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_page_reads"),
			"(BufferManager.Extensionpagereads)",
			[]string{"instance"},
			nil,
		),
		BufManExtensionpageunreferencedtime: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_page_unreferenced_seconds"),
			"(BufferManager.Extensionpageunreferencedtime)",
			[]string{"instance"},
			nil,
		),
		BufManExtensionpagewrites: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_extension_page_writes"),
			"(BufferManager.Extensionpagewrites)",
			[]string{"instance"},
			nil,
		),
		BufManFreeliststalls: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_free_list_stalls"),
			"(BufferManager.Freeliststalls)",
			[]string{"instance"},
			nil,
		),
		BufManIntegralControllerSlope: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_integral_controller_slope"),
			"(BufferManager.IntegralControllerSlope)",
			[]string{"instance"},
			nil,
		),
		BufManLazywrites: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_lazywrites"),
			"(BufferManager.Lazywrites)",
			[]string{"instance"},
			nil,
		),
		BufManPagelifeexpectancy: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_page_life_expectancy_seconds"),
			"(BufferManager.Pagelifeexpectancy)",
			[]string{"instance"},
			nil,
		),
		BufManPagelookups: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_page_lookups"),
			"(BufferManager.Pagelookups)",
			[]string{"instance"},
			nil,
		),
		BufManPagereads: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_page_reads"),
			"(BufferManager.Pagereads)",
			[]string{"instance"},
			nil,
		),
		BufManPagewrites: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_page_writes"),
			"(BufferManager.Pagewrites)",
			[]string{"instance"},
			nil,
		),
		BufManReadaheadpages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_read_ahead_pages"),
			"(BufferManager.Readaheadpages)",
			[]string{"instance"},
			nil,
		),
		BufManReadaheadtime: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_read_ahead_issuing_seconds"),
			"(BufferManager.Readaheadtime)",
			[]string{"instance"},
			nil,
		),
		BufManTargetpages: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "bufman_target_pages"),
			"(BufferManager.Targetpages)",
			[]string{"instance"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerDatabaseReplica
		DBReplicaDatabaseFlowControlDelay: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_database_flow_control_wait_seconds"),
			"(DatabaseReplica.DatabaseFlowControlDelay)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaDatabaseFlowControls: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_database_initiated_flow_controls"),
			"(DatabaseReplica.DatabaseFlowControls)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaFileBytesReceived: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_received_file_bytes"),
			"(DatabaseReplica.FileBytesReceived)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaGroupCommits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_group_commits"),
			"(DatabaseReplica.GroupCommits)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaGroupCommitTime: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_group_commit_stall_seconds"),
			"(DatabaseReplica.GroupCommitTime)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogApplyPendingQueue: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_apply_pending_queue"),
			"(DatabaseReplica.LogApplyPendingQueue)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogApplyReadyQueue: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_apply_ready_queue"),
			"(DatabaseReplica.LogApplyReadyQueue)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogBytesCompressed: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_compressed_bytes"),
			"(DatabaseReplica.LogBytesCompressed)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogBytesDecompressed: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_decompressed_bytes"),
			"(DatabaseReplica.LogBytesDecompressed)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogBytesReceived: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_received_bytes"),
			"(DatabaseReplica.LogBytesReceived)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogCompressionCachehits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_compression_cachehits"),
			"(DatabaseReplica.LogCompressionCachehits)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogCompressionCachemisses: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_compression_cachemisses"),
			"(DatabaseReplica.LogCompressionCachemisses)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogCompressions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_compressions"),
			"(DatabaseReplica.LogCompressions)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogDecompressions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_decompressions"),
			"(DatabaseReplica.LogDecompressions)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogremainingforundo: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_remaining_for_undo"),
			"(DatabaseReplica.Logremainingforundo)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaLogSendQueue: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_log_send_queue"),
			"(DatabaseReplica.LogSendQueue)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaMirroredWriteTransactions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_mirrored_write_transactions"),
			"(DatabaseReplica.MirroredWriteTransactions)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaRecoveryQueue: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_recovery_queue_records"),
			"(DatabaseReplica.RecoveryQueue)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaRedoblocked: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_redo_blocks"),
			"(DatabaseReplica.Redoblocked)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaRedoBytesRemaining: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_redo_remaining_bytes"),
			"(DatabaseReplica.RedoBytesRemaining)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaRedoneBytes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_redone_bytes"),
			"(DatabaseReplica.RedoneBytes)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaRedones: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_redones"),
			"(DatabaseReplica.Redones)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaTotalLogrequiringundo: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_total_log_requiring_undo"),
			"(DatabaseReplica.TotalLogrequiringundo)",
			[]string{"instance", "replica"},
			nil,
		),
		DBReplicaTransactionDelay: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "dbreplica_transaction_delay_seconds"),
			"(DatabaseReplica.TransactionDelay)",
			[]string{"instance", "replica"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerDatabases
		DatabasesActiveTransactions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_active_transactions"),
			"(Databases.ActiveTransactions)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesBackupPerRestoreThroughput: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_backup_restore_operations"),
			"(Databases.BackupPerRestoreThroughput)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesBulkCopyRows: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_bulk_copy_rows"),
			"(Databases.BulkCopyRows)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesBulkCopyThroughput: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_bulk_copy_bytes"),
			"(Databases.BulkCopyThroughput)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesCommittableentries: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_commit_table_entries"),
			"(Databases.Committableentries)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesDataFilesSizeKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_data_files_size_bytes"),
			"(Databases.DataFilesSizeKB)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesDBCCLogicalScanBytes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_dbcc_logical_scan_bytes"),
			"(Databases.DBCCLogicalScanBytes)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesGroupCommitTime: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_group_commit_stall_seconds"),
			"(Databases.GroupCommitTime)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogBytesFlushed: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_flushed_bytes"),
			"(Databases.LogBytesFlushed)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogCacheHitRatio: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_cache_hit_ratio"),
			"(Databases.LogCacheHitRatio)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogCacheReads: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_cache_reads"),
			"(Databases.LogCacheReads)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogFilesSizeKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_files_size_bytes"),
			"(Databases.LogFilesSizeKB)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogFilesUsedSizeKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_files_used_size_bytes"),
			"(Databases.LogFilesUsedSizeKB)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogFlushes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_flushes"),
			"(Databases.LogFlushes)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogFlushWaits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_flush_waits"),
			"(Databases.LogFlushWaits)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogFlushWaitTime: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_flush_wait_seconds"),
			"(Databases.LogFlushWaitTime)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogFlushWriteTimems: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_flush_write_seconds"),
			"(Databases.LogFlushWriteTimems)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogGrowths: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_growths"),
			"(Databases.LogGrowths)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolCacheMisses: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_cache_misses"),
			"(Databases.LogPoolCacheMisses)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolDiskReads: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_disk_reads"),
			"(Databases.LogPoolDiskReads)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolHashDeletes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_hash_deletes"),
			"(Databases.LogPoolHashDeletes)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolHashInserts: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_hash_inserts"),
			"(Databases.LogPoolHashInserts)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolInvalidHashEntry: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_invalid_hash_entries"),
			"(Databases.LogPoolInvalidHashEntry)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolLogScanPushes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_log_scan_pushes"),
			"(Databases.LogPoolLogScanPushes)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolLogWriterPushes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_log_writer_pushes"),
			"(Databases.LogPoolLogWriterPushes)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolPushEmptyFreePool: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_empty_free_pool_pushes"),
			"(Databases.LogPoolPushEmptyFreePool)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolPushLowMemory: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_low_memory_pushes"),
			"(Databases.LogPoolPushLowMemory)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolPushNoFreeBuffer: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_no_free_buffer_pushes"),
			"(Databases.LogPoolPushNoFreeBuffer)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolReqBehindTrunc: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_req_behind_trunc"),
			"(Databases.LogPoolReqBehindTrunc)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolRequestsOldVLF: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_requests_old_vlf"),
			"(Databases.LogPoolRequestsOldVLF)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_requests"),
			"(Databases.LogPoolRequests)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolTotalActiveLogSize: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_total_active_log_bytes"),
			"(Databases.LogPoolTotalActiveLogSize)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogPoolTotalSharedPoolSize: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_pool_total_shared_pool_bytes"),
			"(Databases.LogPoolTotalSharedPoolSize)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogShrinks: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_shrinks"),
			"(Databases.LogShrinks)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesLogTruncations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_truncations"),
			"(Databases.LogTruncations)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesPercentLogUsed: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_log_used_percent"),
			"(Databases.PercentLogUsed)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesReplPendingXacts: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_pending_repl_transactions"),
			"(Databases.ReplPendingTransactions)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesReplTransRate: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_repl_transactions"),
			"(Databases.ReplTranactions)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesShrinkDataMovementBytes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_shrink_data_movement_bytes"),
			"(Databases.ShrinkDataMovementBytes)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesTrackedtransactions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_tracked_transactions"),
			"(Databases.Trackedtransactions)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesTransactions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_transactions"),
			"(Databases.Transactions)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesWriteTransactions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_write_transactions"),
			"(Databases.WriteTransactions)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesXTPControllerDLCLatencyPerFetch: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_xtp_controller_dlc_fetch_latency_seconds"),
			"(Databases.XTPControllerDLCLatencyPerFetch)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesXTPControllerDLCPeakLatency: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_xtp_controller_dlc_peak_latency_seconds"),
			"(Databases.XTPControllerDLCPeakLatency)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesXTPControllerLogProcessed: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_xtp_controller_log_processed_bytes"),
			"(Databases.XTPControllerLogProcessed)",
			[]string{"instance", "database"},
			nil,
		),
		DatabasesXTPMemoryUsedKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "databases_xtp_memory_used_bytes"),
			"(Databases.XTPMemoryUsedKB)",
			[]string{"instance", "database"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerGeneralStatistics
		GenStatsActiveTempTables: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_active_temp_tables"),
			"(GeneralStatistics.ActiveTempTables)",
			[]string{"instance"},
			nil,
		),
		GenStatsConnectionReset: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_connection_resets"),
			"(GeneralStatistics.ConnectionReset)",
			[]string{"instance"},
			nil,
		),
		GenStatsEventNotificationsDelayedDrop: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_event_notifications_delayed_drop"),
			"(GeneralStatistics.EventNotificationsDelayedDrop)",
			[]string{"instance"},
			nil,
		),
		GenStatsHTTPAuthenticatedRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_http_authenticated_requests"),
			"(GeneralStatistics.HTTPAuthenticatedRequests)",
			[]string{"instance"},
			nil,
		),
		GenStatsLogicalConnections: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_logical_connections"),
			"(GeneralStatistics.LogicalConnections)",
			[]string{"instance"},
			nil,
		),
		GenStatsLogins: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_logins"),
			"(GeneralStatistics.Logins)",
			[]string{"instance"},
			nil,
		),
		GenStatsLogouts: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_logouts"),
			"(GeneralStatistics.Logouts)",
			[]string{"instance"},
			nil,
		),
		GenStatsMarsDeadlocks: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_mars_deadlocks"),
			"(GeneralStatistics.MarsDeadlocks)",
			[]string{"instance"},
			nil,
		),
		GenStatsNonatomicyieldrate: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_non_atomic_yields"),
			"(GeneralStatistics.Nonatomicyields)",
			[]string{"instance"},
			nil,
		),
		GenStatsProcessesblocked: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_blocked_processes"),
			"(GeneralStatistics.Processesblocked)",
			[]string{"instance"},
			nil,
		),
		GenStatsSOAPEmptyRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_soap_empty_requests"),
			"(GeneralStatistics.SOAPEmptyRequests)",
			[]string{"instance"},
			nil,
		),
		GenStatsSOAPMethodInvocations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_soap_method_invocations"),
			"(GeneralStatistics.SOAPMethodInvocations)",
			[]string{"instance"},
			nil,
		),
		GenStatsSOAPSessionInitiateRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_soap_session_initiate_requests"),
			"(GeneralStatistics.SOAPSessionInitiateRequests)",
			[]string{"instance"},
			nil,
		),
		GenStatsSOAPSessionTerminateRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_soap_session_terminate_requests"),
			"(GeneralStatistics.SOAPSessionTerminateRequests)",
			[]string{"instance"},
			nil,
		),
		GenStatsSOAPSQLRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_soapsql_requests"),
			"(GeneralStatistics.SOAPSQLRequests)",
			[]string{"instance"},
			nil,
		),
		GenStatsSOAPWSDLRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_soapwsdl_requests"),
			"(GeneralStatistics.SOAPWSDLRequests)",
			[]string{"instance"},
			nil,
		),
		GenStatsSQLTraceIOProviderLockWaits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_sql_trace_io_provider_lock_waits"),
			"(GeneralStatistics.SQLTraceIOProviderLockWaits)",
			[]string{"instance"},
			nil,
		),
		GenStatsTempdbrecoveryunitid: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_tempdb_recovery_unit_ids_generated"),
			"(GeneralStatistics.Tempdbrecoveryunitid)",
			[]string{"instance"},
			nil,
		),
		GenStatsTempdbrowsetid: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_tempdb_rowset_ids_generated"),
			"(GeneralStatistics.Tempdbrowsetid)",
			[]string{"instance"},
			nil,
		),
		GenStatsTempTablesCreationRate: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_temp_tables_creations"),
			"(GeneralStatistics.TempTablesCreations)",
			[]string{"instance"},
			nil,
		),
		GenStatsTempTablesForDestruction: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_temp_tables_awaiting_destruction"),
			"(GeneralStatistics.TempTablesForDestruction)",
			[]string{"instance"},
			nil,
		),
		GenStatsTraceEventNotificationQueue: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_trace_event_notification_queue_size"),
			"(GeneralStatistics.TraceEventNotificationQueue)",
			[]string{"instance"},
			nil,
		),
		GenStatsTransactions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_transactions"),
			"(GeneralStatistics.Transactions)",
			[]string{"instance"},
			nil,
		),
		GenStatsUserConnections: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "genstats_user_connections"),
			"(GeneralStatistics.UserConnections)",
			[]string{"instance"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerLocks
		LocksAverageWaitTimems: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "locks_average_wait_seconds"),
			"(Locks.AverageWaitTimems)",
			[]string{"instance", "resource"},
			nil,
		),
		LocksLockRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "locks_lock_requests"),
			"(Locks.LockRequests)",
			[]string{"instance", "resource"},
			nil,
		),
		LocksLockTimeouts: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "locks_lock_timeouts"),
			"(Locks.LockTimeouts)",
			[]string{"instance", "resource"},
			nil,
		),
		LocksLockTimeoutstimeout0: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "locks_lock_timeouts_excluding_NOWAIT"),
			"(Locks.LockTimeoutstimeout0)",
			[]string{"instance", "resource"},
			nil,
		),
		LocksLockWaits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "locks_lock_waits"),
			"(Locks.LockWaits)",
			[]string{"instance", "resource"},
			nil,
		),
		LocksLockWaitTimems: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "locks_lock_wait_seconds"),
			"(Locks.LockWaitTimems)",
			[]string{"instance", "resource"},
			nil,
		),
		LocksNumberofDeadlocks: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "locks_deadlocks"),
			"(Locks.NumberofDeadlocks)",
			[]string{"instance", "resource"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerMemoryManager
		MemMgrConnectionMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_connection_memory_bytes"),
			"(MemoryManager.ConnectionMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrDatabaseCacheMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_database_cache_memory_bytes"),
			"(MemoryManager.DatabaseCacheMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrExternalbenefitofmemory: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_external_benefit_of_memory"),
			"(MemoryManager.Externalbenefitofmemory)",
			[]string{"instance"},
			nil,
		),
		MemMgrFreeMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_free_memory_bytes"),
			"(MemoryManager.FreeMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrGrantedWorkspaceMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_granted_workspace_memory_bytes"),
			"(MemoryManager.GrantedWorkspaceMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrLockBlocks: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_lock_blocks"),
			"(MemoryManager.LockBlocks)",
			[]string{"instance"},
			nil,
		),
		MemMgrLockBlocksAllocated: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_allocated_lock_blocks"),
			"(MemoryManager.LockBlocksAllocated)",
			[]string{"instance"},
			nil,
		),
		MemMgrLockMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_lock_memory_bytes"),
			"(MemoryManager.LockMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrLockOwnerBlocks: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_lock_owner_blocks"),
			"(MemoryManager.LockOwnerBlocks)",
			[]string{"instance"},
			nil,
		),
		MemMgrLockOwnerBlocksAllocated: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_allocated_lock_owner_blocks"),
			"(MemoryManager.LockOwnerBlocksAllocated)",
			[]string{"instance"},
			nil,
		),
		MemMgrLogPoolMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_log_pool_memory_bytes"),
			"(MemoryManager.LogPoolMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrMaximumWorkspaceMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_maximum_workspace_memory_bytes"),
			"(MemoryManager.MaximumWorkspaceMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrMemoryGrantsOutstanding: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_outstanding_memory_grants"),
			"(MemoryManager.MemoryGrantsOutstanding)",
			[]string{"instance"},
			nil,
		),
		MemMgrMemoryGrantsPending: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_pending_memory_grants"),
			"(MemoryManager.MemoryGrantsPending)",
			[]string{"instance"},
			nil,
		),
		MemMgrOptimizerMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_optimizer_memory_bytes"),
			"(MemoryManager.OptimizerMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrReservedServerMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_reserved_server_memory_bytes"),
			"(MemoryManager.ReservedServerMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrSQLCacheMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_sql_cache_memory_bytes"),
			"(MemoryManager.SQLCacheMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrStolenServerMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_stolen_server_memory_bytes"),
			"(MemoryManager.StolenServerMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrTargetServerMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_target_server_memory_bytes"),
			"(MemoryManager.TargetServerMemoryKB)",
			[]string{"instance"},
			nil,
		),
		MemMgrTotalServerMemoryKB: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "memmgr_total_server_memory_bytes"),
			"(MemoryManager.TotalServerMemoryKB)",
			[]string{"instance"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerSQLStatistics
		SQLStatsAutoParamAttempts: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_auto_parameterization_attempts"),
			"(SQLStatistics.AutoParamAttempts)",
			[]string{"instance"},
			nil,
		),
		SQLStatsBatchRequests: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_batch_requests"),
			"(SQLStatistics.BatchRequests)",
			[]string{"instance"},
			nil,
		),
		SQLStatsFailedAutoParams: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_failed_auto_parameterization_attempts"),
			"(SQLStatistics.FailedAutoParams)",
			[]string{"instance"},
			nil,
		),
		SQLStatsForcedParameterizations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_forced_parameterizations"),
			"(SQLStatistics.ForcedParameterizations)",
			[]string{"instance"},
			nil,
		),
		SQLStatsGuidedplanexecutions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_guided_plan_executions"),
			"(SQLStatistics.Guidedplanexecutions)",
			[]string{"instance"},
			nil,
		),
		SQLStatsMisguidedplanexecutions: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_misguided_plan_executions"),
			"(SQLStatistics.Misguidedplanexecutions)",
			[]string{"instance"},
			nil,
		),
		SQLStatsSafeAutoParams: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_safe_auto_parameterization_attempts"),
			"(SQLStatistics.SafeAutoParams)",
			[]string{"instance"},
			nil,
		),
		SQLStatsSQLAttentionrate: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_sql_attentions"),
			"(SQLStatistics.SQLAttentions)",
			[]string{"instance"},
			nil,
		),
		SQLStatsSQLCompilations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_sql_compilations"),
			"(SQLStatistics.SQLCompilations)",
			[]string{"instance"},
			nil,
		),
		SQLStatsSQLReCompilations: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_sql_recompilations"),
			"(SQLStatistics.SQLReCompilations)",
			[]string{"instance"},
			nil,
		),
		SQLStatsUnsafeAutoParams: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sqlstats_unsafe_auto_parameterization_attempts"),
			"(SQLStatistics.UnsafeAutoParams)",
			[]string{"instance"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerSQLErrors
		SQLErrorsTotal: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "sql_errors_total"),
			"(SQLErrors.Total)",
			[]string{"instance", "resource"},
			nil,
		),

		// Win32_PerfRawData_{instance}_SQLServerTransactions
		TransactionsTempDbFreeSpaceBytes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_tempdb_free_space_bytes"),
			"(Transactions.FreeSpaceInTempDbKB)",
			[]string{"instance"},
			nil,
		),
		TransactionsLongestTransactionRunningSeconds: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_longest_transaction_running_seconds"),
			"(Transactions.LongestTransactionRunningTime)",
			[]string{"instance"},
			nil,
		),
		TransactionsNonSnapshotVersionActiveTotal: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_nonsnapshot_version_active_total"),
			"(Transactions.NonSnapshotVersionTransactions)",
			[]string{"instance"},
			nil,
		),
		TransactionsSnapshotActiveTotal: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_snapshot_active_total"),
			"(Transactions.SnapshotTransactions)",
			[]string{"instance"},
			nil,
		),
		TransactionsActiveTotal: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_active_total"),
			"(Transactions.Transactions)",
			[]string{"instance"},
			nil,
		),
		TransactionsUpdateConflictsTotal: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_update_conflicts_total"),
			"(Transactions.UpdateConflictRatio)",
			[]string{"instance"},
			nil,
		),
		TransactionsUpdateSnapshotActiveTotal: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_update_snapshot_active_total"),
			"(Transactions.UpdateSnapshotTransactions)",
			[]string{"instance"},
			nil,
		),
		TransactionsVersionCleanupRateBytes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_cleanup_rate_bytes"),
			"(Transactions.VersionCleanupRateKBs)",
			[]string{"instance"},
			nil,
		),
		TransactionsVersionGenerationRateBytes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_generation_rate_bytes"),
			"(Transactions.VersionGenerationRateKBs)",
			[]string{"instance"},
			nil,
		),
		TransactionsVersionStoreSizeBytes: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_size_bytes"),
			"(Transactions.VersionStoreSizeKB)",
			[]string{"instance"},
			nil,
		),
		TransactionsVersionStoreUnits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_units"),
			"(Transactions.VersionStoreUnitCount)",
			[]string{"instance"},
			nil,
		),
		TransactionsVersionStoreCreationUnits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_creation_units"),
			"(Transactions.VersionStoreUnitCreation)",
			[]string{"instance"},
			nil,
		),
		TransactionsVersionStoreTruncationUnits: prometheus.NewDesc(
			prometheus.BuildFQName(Namespace, subsystem, "transactions_version_store_truncation_units"),
			"(Transactions.VersionStoreUnitTruncation)",
			[]string{"instance"},
			nil,
		),

		mssqlInstances: getMSSQLInstances(),
	}

	mssqlCollector.mssqlCollectors = mssqlCollector.getMSSQLCollectors()

	if *mssqlPrintCollectors {
		fmt.Printf("Available SQLServer Classes:\n")
		for name := range mssqlCollector.mssqlCollectors {
			fmt.Printf(" - %s\n", name)
		}
		os.Exit(0)
	}

	return &mssqlCollector, nil
}

type mssqlCollectorFunc func(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error)

func (c *MSSQLCollector) execute(name string, fn mssqlCollectorFunc, ch chan<- prometheus.Metric, sqlInstance string, wg *sync.WaitGroup) {
	defer wg.Done()

	begin := time.Now()
	_, err := fn(ch, sqlInstance)
	duration := time.Since(begin)
	var success float64

	if err != nil {
		log.Errorf("mssql class collector %s failed after %fs: %s", name, duration.Seconds(), err)
		success = 0
		c.mssqlChildCollectorFailure++
	} else {
		log.Debugf("mssql class collector %s succeeded after %fs.", name, duration.Seconds())
		success = 1
	}
	ch <- prometheus.MustNewConstMetric(
		c.mssqlScrapeDurationDesc,
		prometheus.GaugeValue,
		duration.Seconds(),
		name, sqlInstance,
	)
	ch <- prometheus.MustNewConstMetric(
		c.mssqlScrapeSuccessDesc,
		prometheus.GaugeValue,
		success,
		name, sqlInstance,
	)
}

// Collect sends the metric values for each metric
// to the provided prometheus Metric channel.
func (c *MSSQLCollector) Collect(ctx *ScrapeContext, ch chan<- prometheus.Metric) error {
	wg := sync.WaitGroup{}

	enabled := mssqlExpandEnabledCollectors(*mssqlEnabledCollectors)
	for sqlInstance := range c.mssqlInstances {
		for _, name := range enabled {
			function := c.mssqlCollectors[name]

			wg.Add(1)
			go c.execute(name, function, ch, sqlInstance, &wg)
		}
	}
	wg.Wait()

	// this shoud return an error if any? some? children errord.
	if c.mssqlChildCollectorFailure > 0 {
		return errors.New("at least one child collector failed")
	}
	return nil
}

// win32PerfRawDataSQLServerAccessMethods docs:
// - Win32_PerfRawData_MSSQLSERVER_SQLServerAccessMethods
//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-access-methods-object
type win32PerfRawDataSQLServerAccessMethods struct {
	AUcleanupbatchesPersec        uint64
	AUcleanupsPersec              uint64
	ByreferenceLobCreateCount     uint64
	ByreferenceLobUseCount        uint64
	CountLobReadahead             uint64
	CountPullInRow                uint64
	CountPushOffRow               uint64
	DeferreddroppedAUs            uint64
	DeferredDroppedrowsets        uint64
	DroppedrowsetcleanupsPersec   uint64
	DroppedrowsetsskippedPersec   uint64
	ExtentDeallocationsPersec     uint64
	ExtentsAllocatedPersec        uint64
	FailedAUcleanupbatchesPersec  uint64
	Failedleafpagecookie          uint64
	Failedtreepagecookie          uint64
	ForwardedRecordsPersec        uint64
	FreeSpacePageFetchesPersec    uint64
	FreeSpaceScansPersec          uint64
	FullScansPersec               uint64
	IndexSearchesPersec           uint64
	InSysXactwaitsPersec          uint64
	LobHandleCreateCount          uint64
	LobHandleDestroyCount         uint64
	LobSSProviderCreateCount      uint64
	LobSSProviderDestroyCount     uint64
	LobSSProviderTruncationCount  uint64
	MixedpageallocationsPersec    uint64
	PagecompressionattemptsPersec uint64
	PageDeallocationsPersec       uint64
	PagesAllocatedPersec          uint64
	PagescompressedPersec         uint64
	PageSplitsPersec              uint64
	ProbeScansPersec              uint64
	RangeScansPersec              uint64
	ScanPointRevalidationsPersec  uint64
	SkippedGhostedRecordsPersec   uint64
	TableLockEscalationsPersec    uint64
	Usedleafpagecookie            uint64
	Usedtreepagecookie            uint64
	WorkfilesCreatedPersec        uint64
	WorktablesCreatedPersec       uint64
	WorktablesFromCacheRatio      uint64
}

func (c *MSSQLCollector) collectAccessMethods(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerAccessMethods
	log.Debugf("mssql_accessmethods collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("AccessMethods", sqlInstance)
	q := queryAllForClass(&dst, class)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	if len(dst) == 0 {
		return nil, errors.New("WMI query returned empty result set")
	}

	v := dst[0]
	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsAUcleanupbatches,
		prometheus.CounterValue,
		float64(v.AUcleanupbatchesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsAUcleanups,
		prometheus.CounterValue,
		float64(v.AUcleanupsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsByreferenceLobCreateCount,
		prometheus.CounterValue,
		float64(v.ByreferenceLobCreateCount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsByreferenceLobUseCount,
		prometheus.CounterValue,
		float64(v.ByreferenceLobUseCount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsCountLobReadahead,
		prometheus.CounterValue,
		float64(v.CountLobReadahead),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsCountPullInRow,
		prometheus.CounterValue,
		float64(v.CountPullInRow),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsCountPushOffRow,
		prometheus.CounterValue,
		float64(v.CountPushOffRow),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsDeferreddroppedAUs,
		prometheus.GaugeValue,
		float64(v.DeferreddroppedAUs),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsDeferredDroppedrowsets,
		prometheus.GaugeValue,
		float64(v.DeferredDroppedrowsets),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsDroppedrowsetcleanups,
		prometheus.CounterValue,
		float64(v.DroppedrowsetcleanupsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsDroppedrowsetsskipped,
		prometheus.CounterValue,
		float64(v.DroppedrowsetsskippedPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsExtentDeallocations,
		prometheus.CounterValue,
		float64(v.ExtentDeallocationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsExtentsAllocated,
		prometheus.CounterValue,
		float64(v.ExtentsAllocatedPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsFailedAUcleanupbatches,
		prometheus.CounterValue,
		float64(v.FailedAUcleanupbatchesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsFailedleafpagecookie,
		prometheus.CounterValue,
		float64(v.Failedleafpagecookie),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsFailedtreepagecookie,
		prometheus.CounterValue,
		float64(v.Failedtreepagecookie),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsForwardedRecords,
		prometheus.CounterValue,
		float64(v.ForwardedRecordsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsFreeSpacePageFetches,
		prometheus.CounterValue,
		float64(v.FreeSpacePageFetchesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsFreeSpaceScans,
		prometheus.CounterValue,
		float64(v.FreeSpaceScansPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsFullScans,
		prometheus.CounterValue,
		float64(v.FullScansPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsIndexSearches,
		prometheus.CounterValue,
		float64(v.IndexSearchesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsInSysXactwaits,
		prometheus.CounterValue,
		float64(v.InSysXactwaitsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsLobHandleCreateCount,
		prometheus.CounterValue,
		float64(v.LobHandleCreateCount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsLobHandleDestroyCount,
		prometheus.CounterValue,
		float64(v.LobHandleDestroyCount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsLobSSProviderCreateCount,
		prometheus.CounterValue,
		float64(v.LobSSProviderCreateCount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsLobSSProviderDestroyCount,
		prometheus.CounterValue,
		float64(v.LobSSProviderDestroyCount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsLobSSProviderTruncationCount,
		prometheus.CounterValue,
		float64(v.LobSSProviderTruncationCount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsMixedpageallocations,
		prometheus.CounterValue,
		float64(v.MixedpageallocationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsPagecompressionattempts,
		prometheus.CounterValue,
		float64(v.PagecompressionattemptsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsPageDeallocations,
		prometheus.CounterValue,
		float64(v.PageDeallocationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsPagesAllocated,
		prometheus.CounterValue,
		float64(v.PagesAllocatedPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsPagescompressed,
		prometheus.CounterValue,
		float64(v.PagescompressedPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsPageSplits,
		prometheus.CounterValue,
		float64(v.PageSplitsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsProbeScans,
		prometheus.CounterValue,
		float64(v.ProbeScansPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsRangeScans,
		prometheus.CounterValue,
		float64(v.RangeScansPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsScanPointRevalidations,
		prometheus.CounterValue,
		float64(v.ScanPointRevalidationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsSkippedGhostedRecords,
		prometheus.CounterValue,
		float64(v.SkippedGhostedRecordsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsTableLockEscalations,
		prometheus.CounterValue,
		float64(v.TableLockEscalationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsUsedleafpagecookie,
		prometheus.CounterValue,
		float64(v.Usedleafpagecookie),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsUsedtreepagecookie,
		prometheus.CounterValue,
		float64(v.Usedtreepagecookie),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsWorkfilesCreated,
		prometheus.CounterValue,
		float64(v.WorkfilesCreatedPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsWorktablesCreated,
		prometheus.CounterValue,
		float64(v.WorktablesCreatedPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.AccessMethodsWorktablesFromCacheRatio,
		prometheus.CounterValue,
		float64(v.WorktablesFromCacheRatio),
		sqlInstance,
	)
	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerAvailabilityReplica docs:
//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-availability-replica
type win32PerfRawDataSQLServerAvailabilityReplica struct {
	Name                           string
	BytesReceivedfromReplicaPersec uint64
	BytesSenttoReplicaPersec       uint64
	BytesSenttoTransportPersec     uint64
	FlowControlPersec              uint64
	FlowControlTimemsPersec        uint64
	ReceivesfromReplicaPersec      uint64
	ResentMessagesPersec           uint64
	SendstoReplicaPersec           uint64
	SendstoTransportPersec         uint64
}

func (c *MSSQLCollector) collectAvailabilityReplica(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerAvailabilityReplica
	log.Debugf("mssql_availreplica collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("AvailabilityReplica", sqlInstance)
	q := queryAllForClassWhere(&dst, class, `Name <> '_Total'`)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	for _, v := range dst {
		replicaName := v.Name

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaBytesReceivedfromReplica,
			prometheus.CounterValue,
			float64(v.BytesReceivedfromReplicaPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaBytesSenttoReplica,
			prometheus.CounterValue,
			float64(v.BytesSenttoReplicaPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaBytesSenttoTransport,
			prometheus.CounterValue,
			float64(v.BytesSenttoTransportPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaFlowControl,
			prometheus.CounterValue,
			float64(v.FlowControlPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaFlowControlTimems,
			prometheus.CounterValue,
			float64(v.FlowControlTimemsPersec)/1000.0,
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaReceivesfromReplica,
			prometheus.CounterValue,
			float64(v.ReceivesfromReplicaPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaResentMessages,
			prometheus.CounterValue,
			float64(v.ResentMessagesPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaSendstoReplica,
			prometheus.CounterValue,
			float64(v.SendstoReplicaPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.AvailReplicaSendstoTransport,
			prometheus.CounterValue,
			float64(v.SendstoTransportPersec),
			sqlInstance, replicaName,
		)
	}
	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerBufferManager docs:
//   https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-buffer-manager-object
type win32PerfRawDataSQLServerBufferManager struct {
	BackgroundwriterpagesPersec   uint64
	Buffercachehitratio           uint64
	CheckpointpagesPersec         uint64
	Databasepages                 uint64
	Extensionallocatedpages       uint64
	Extensionfreepages            uint64
	Extensioninuseaspercentage    uint64
	ExtensionoutstandingIOcounter uint64
	ExtensionpageevictionsPersec  uint64
	ExtensionpagereadsPersec      uint64
	Extensionpageunreferencedtime uint64
	ExtensionpagewritesPersec     uint64
	FreeliststallsPersec          uint64
	IntegralControllerSlope       uint64
	LazywritesPersec              uint64
	Pagelifeexpectancy            uint64
	PagelookupsPersec             uint64
	PagereadsPersec               uint64
	PagewritesPersec              uint64
	ReadaheadpagesPersec          uint64
	ReadaheadtimePersec           uint64
	Targetpages                   uint64
}

func (c *MSSQLCollector) collectBufferManager(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerBufferManager
	log.Debugf("mssql_bufman collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("BufferManager", sqlInstance)
	q := queryAllForClass(&dst, class)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}
	if len(dst) == 0 {
		return nil, errors.New("WMI query returned empty result set")
	}

	v := dst[0]

	ch <- prometheus.MustNewConstMetric(
		c.BufManBackgroundwriterpages,
		prometheus.CounterValue,
		float64(v.BackgroundwriterpagesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManBuffercachehitratio,
		prometheus.GaugeValue,
		float64(v.Buffercachehitratio),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManCheckpointpages,
		prometheus.CounterValue,
		float64(v.CheckpointpagesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManDatabasepages,
		prometheus.GaugeValue,
		float64(v.Databasepages),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensionallocatedpages,
		prometheus.GaugeValue,
		float64(v.Extensionallocatedpages),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensionfreepages,
		prometheus.GaugeValue,
		float64(v.Extensionfreepages),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensioninuseaspercentage,
		prometheus.GaugeValue,
		float64(v.Extensioninuseaspercentage),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensionoutstandingIOcounter,
		prometheus.GaugeValue,
		float64(v.ExtensionoutstandingIOcounter),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensionpageevictions,
		prometheus.CounterValue,
		float64(v.ExtensionpageevictionsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensionpagereads,
		prometheus.CounterValue,
		float64(v.ExtensionpagereadsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensionpageunreferencedtime,
		prometheus.GaugeValue,
		float64(v.Extensionpageunreferencedtime),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManExtensionpagewrites,
		prometheus.CounterValue,
		float64(v.ExtensionpagewritesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManFreeliststalls,
		prometheus.CounterValue,
		float64(v.FreeliststallsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManIntegralControllerSlope,
		prometheus.GaugeValue,
		float64(v.IntegralControllerSlope),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManLazywrites,
		prometheus.CounterValue,
		float64(v.LazywritesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManPagelifeexpectancy,
		prometheus.GaugeValue,
		float64(v.Pagelifeexpectancy),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManPagelookups,
		prometheus.CounterValue,
		float64(v.PagelookupsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManPagereads,
		prometheus.CounterValue,
		float64(v.PagereadsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManPagewrites,
		prometheus.CounterValue,
		float64(v.PagewritesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManReadaheadpages,
		prometheus.CounterValue,
		float64(v.ReadaheadpagesPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManReadaheadtime,
		prometheus.CounterValue,
		float64(v.ReadaheadtimePersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.BufManTargetpages,
		prometheus.GaugeValue,
		float64(v.Targetpages),
		sqlInstance,
	)

	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerDatabaseReplica docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-database-replica
type win32PerfRawDataSQLServerDatabaseReplica struct {
	Name                            string
	DatabaseFlowControlDelay        uint64
	DatabaseFlowControlsPersec      uint64
	FileBytesReceivedPersec         uint64
	GroupCommitsPerSec              uint64
	GroupCommitTime                 uint64
	LogApplyPendingQueue            uint64
	LogApplyReadyQueue              uint64
	LogBytesCompressedPersec        uint64
	LogBytesDecompressedPersec      uint64
	LogBytesReceivedPersec          uint64
	LogCompressionCachehitsPersec   uint64
	LogCompressionCachemissesPersec uint64
	LogCompressionsPersec           uint64
	LogDecompressionsPersec         uint64
	Logremainingforundo             uint64
	LogSendQueue                    uint64
	MirroredWriteTransactionsPersec uint64
	RecoveryQueue                   uint64
	RedoblockedPersec               uint64
	RedoBytesRemaining              uint64
	RedoneBytesPersec               uint64
	RedonesPersec                   uint64
	TotalLogrequiringundo           uint64
	TransactionDelay                uint64
}

func (c *MSSQLCollector) collectDatabaseReplica(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerDatabaseReplica
	log.Debugf("mssql_dbreplica collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("DatabaseReplica", sqlInstance)
	q := queryAllForClassWhere(&dst, class, `Name <> '_Total'`)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	for _, v := range dst {
		replicaName := v.Name

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaDatabaseFlowControlDelay,
			prometheus.GaugeValue,
			float64(v.DatabaseFlowControlDelay),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaDatabaseFlowControls,
			prometheus.CounterValue,
			float64(v.DatabaseFlowControlsPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaFileBytesReceived,
			prometheus.CounterValue,
			float64(v.FileBytesReceivedPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaGroupCommits,
			prometheus.CounterValue,
			float64(v.GroupCommitsPerSec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaGroupCommitTime,
			prometheus.GaugeValue,
			float64(v.GroupCommitTime),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogApplyPendingQueue,
			prometheus.GaugeValue,
			float64(v.LogApplyPendingQueue),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogApplyReadyQueue,
			prometheus.GaugeValue,
			float64(v.LogApplyReadyQueue),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogBytesCompressed,
			prometheus.CounterValue,
			float64(v.LogBytesCompressedPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogBytesDecompressed,
			prometheus.CounterValue,
			float64(v.LogBytesDecompressedPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogBytesReceived,
			prometheus.CounterValue,
			float64(v.LogBytesReceivedPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogCompressionCachehits,
			prometheus.CounterValue,
			float64(v.LogCompressionCachehitsPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogCompressionCachemisses,
			prometheus.CounterValue,
			float64(v.LogCompressionCachemissesPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogCompressions,
			prometheus.CounterValue,
			float64(v.LogCompressionsPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogDecompressions,
			prometheus.CounterValue,
			float64(v.LogDecompressionsPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogremainingforundo,
			prometheus.GaugeValue,
			float64(v.Logremainingforundo),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaLogSendQueue,
			prometheus.GaugeValue,
			float64(v.LogSendQueue),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaMirroredWriteTransactions,
			prometheus.CounterValue,
			float64(v.MirroredWriteTransactionsPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaRecoveryQueue,
			prometheus.GaugeValue,
			float64(v.RecoveryQueue),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaRedoblocked,
			prometheus.CounterValue,
			float64(v.RedoblockedPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaRedoBytesRemaining,
			prometheus.GaugeValue,
			float64(v.RedoBytesRemaining),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaRedoneBytes,
			prometheus.CounterValue,
			float64(v.RedoneBytesPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaRedones,
			prometheus.CounterValue,
			float64(v.RedonesPersec),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaTotalLogrequiringundo,
			prometheus.GaugeValue,
			float64(v.TotalLogrequiringundo),
			sqlInstance, replicaName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DBReplicaTransactionDelay,
			prometheus.GaugeValue,
			float64(v.TransactionDelay)/1000.0,
			sqlInstance, replicaName,
		)
	}
	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerDatabases docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-databases-object?view=sql-server-2017
type win32PerfRawDataSQLServerDatabases struct {
	Name                             string
	ActiveTransactions               uint64
	BackupPerRestoreThroughputPersec uint64
	BulkCopyRowsPersec               uint64
	BulkCopyThroughputPersec         uint64
	Committableentries               uint64
	DataFilesSizeKB                  uint64
	DBCCLogicalScanBytesPersec       uint64
	GroupCommitTimePersec            uint64
	LogBytesFlushedPersec            uint64
	LogCacheHitRatio                 uint64
	LogCacheReadsPersec              uint64
	LogFilesSizeKB                   uint64
	LogFilesUsedSizeKB               uint64
	LogFlushesPersec                 uint64
	LogFlushWaitsPersec              uint64
	LogFlushWaitTime                 uint64
	LogFlushWriteTimems              uint64
	LogGrowths                       uint64
	LogPoolCacheMissesPersec         uint64
	LogPoolDiskReadsPersec           uint64
	LogPoolHashDeletesPersec         uint64
	LogPoolHashInsertsPersec         uint64
	LogPoolInvalidHashEntryPersec    uint64
	LogPoolLogScanPushesPersec       uint64
	LogPoolLogWriterPushesPersec     uint64
	LogPoolPushEmptyFreePoolPersec   uint64
	LogPoolPushLowMemoryPersec       uint64
	LogPoolPushNoFreeBufferPersec    uint64
	LogPoolReqBehindTruncPersec      uint64
	LogPoolRequestsOldVLFPersec      uint64
	LogPoolRequestsPersec            uint64
	LogPoolTotalActiveLogSize        uint64
	LogPoolTotalSharedPoolSize       uint64
	LogShrinks                       uint64
	LogTruncations                   uint64
	PercentLogUsed                   uint64
	ReplPendingXacts                 uint64
	ReplTransRate                    uint64
	ShrinkDataMovementBytesPersec    uint64
	TrackedtransactionsPersec        uint64
	TransactionsPersec               uint64
	WriteTransactionsPersec          uint64
	XTPControllerDLCLatencyPerFetch  uint64
	XTPControllerDLCPeakLatency      uint64
	XTPControllerLogProcessedPersec  uint64
	XTPMemoryUsedKB                  uint64
}

func (c *MSSQLCollector) collectDatabases(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerDatabases
	log.Debugf("mssql_databases collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("Databases", sqlInstance)
	q := queryAllForClassWhere(&dst, class, `Name <> '_Total'`)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	for _, v := range dst {
		dbName := v.Name

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesActiveTransactions,
			prometheus.GaugeValue,
			float64(v.ActiveTransactions),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesBackupPerRestoreThroughput,
			prometheus.CounterValue,
			float64(v.BackupPerRestoreThroughputPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesBulkCopyRows,
			prometheus.CounterValue,
			float64(v.BulkCopyRowsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesBulkCopyThroughput,
			prometheus.CounterValue,
			float64(v.BulkCopyThroughputPersec)*1024,
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesCommittableentries,
			prometheus.GaugeValue,
			float64(v.Committableentries),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesDataFilesSizeKB,
			prometheus.GaugeValue,
			float64(v.DataFilesSizeKB*1024),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesDBCCLogicalScanBytes,
			prometheus.CounterValue,
			float64(v.DBCCLogicalScanBytesPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesGroupCommitTime,
			prometheus.CounterValue,
			float64(v.GroupCommitTimePersec)/1000000.0,
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogBytesFlushed,
			prometheus.CounterValue,
			float64(v.LogBytesFlushedPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogCacheHitRatio,
			prometheus.GaugeValue,
			float64(v.LogCacheHitRatio),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogCacheReads,
			prometheus.CounterValue,
			float64(v.LogCacheReadsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogFilesSizeKB,
			prometheus.GaugeValue,
			float64(v.LogFilesSizeKB*1024),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogFilesUsedSizeKB,
			prometheus.GaugeValue,
			float64(v.LogFilesUsedSizeKB*1024),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogFlushes,
			prometheus.CounterValue,
			float64(v.LogFlushesPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogFlushWaits,
			prometheus.CounterValue,
			float64(v.LogFlushWaitsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogFlushWaitTime,
			prometheus.GaugeValue,
			float64(v.LogFlushWaitTime)/1000.0,
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogFlushWriteTimems,
			prometheus.GaugeValue,
			float64(v.LogFlushWriteTimems)/1000.0,
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogGrowths,
			prometheus.GaugeValue,
			float64(v.LogGrowths),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolCacheMisses,
			prometheus.CounterValue,
			float64(v.LogPoolCacheMissesPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolDiskReads,
			prometheus.CounterValue,
			float64(v.LogPoolDiskReadsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolHashDeletes,
			prometheus.CounterValue,
			float64(v.LogPoolHashDeletesPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolHashInserts,
			prometheus.CounterValue,
			float64(v.LogPoolHashInsertsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolInvalidHashEntry,
			prometheus.CounterValue,
			float64(v.LogPoolInvalidHashEntryPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolLogScanPushes,
			prometheus.CounterValue,
			float64(v.LogPoolLogScanPushesPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolLogWriterPushes,
			prometheus.CounterValue,
			float64(v.LogPoolLogWriterPushesPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolPushEmptyFreePool,
			prometheus.CounterValue,
			float64(v.LogPoolPushEmptyFreePoolPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolPushLowMemory,
			prometheus.CounterValue,
			float64(v.LogPoolPushLowMemoryPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolPushNoFreeBuffer,
			prometheus.CounterValue,
			float64(v.LogPoolPushNoFreeBufferPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolReqBehindTrunc,
			prometheus.CounterValue,
			float64(v.LogPoolReqBehindTruncPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolRequestsOldVLF,
			prometheus.CounterValue,
			float64(v.LogPoolRequestsOldVLFPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolRequests,
			prometheus.CounterValue,
			float64(v.LogPoolRequestsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolTotalActiveLogSize,
			prometheus.GaugeValue,
			float64(v.LogPoolTotalActiveLogSize),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogPoolTotalSharedPoolSize,
			prometheus.GaugeValue,
			float64(v.LogPoolTotalSharedPoolSize),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogShrinks,
			prometheus.GaugeValue,
			float64(v.LogShrinks),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesLogTruncations,
			prometheus.GaugeValue,
			float64(v.LogTruncations),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesPercentLogUsed,
			prometheus.GaugeValue,
			float64(v.PercentLogUsed),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesReplPendingXacts,
			prometheus.GaugeValue,
			float64(v.ReplPendingXacts),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesReplTransRate,
			prometheus.CounterValue,
			float64(v.ReplTransRate),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesShrinkDataMovementBytes,
			prometheus.CounterValue,
			float64(v.ShrinkDataMovementBytesPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesTrackedtransactions,
			prometheus.CounterValue,
			float64(v.TrackedtransactionsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesTransactions,
			prometheus.CounterValue,
			float64(v.TransactionsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesWriteTransactions,
			prometheus.CounterValue,
			float64(v.WriteTransactionsPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesXTPControllerDLCLatencyPerFetch,
			prometheus.GaugeValue,
			float64(v.XTPControllerDLCLatencyPerFetch),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesXTPControllerDLCPeakLatency,
			prometheus.GaugeValue,
			float64(v.XTPControllerDLCPeakLatency)*1000000.0,
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesXTPControllerLogProcessed,
			prometheus.CounterValue,
			float64(v.XTPControllerLogProcessedPersec),
			sqlInstance, dbName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.DatabasesXTPMemoryUsedKB,
			prometheus.GaugeValue,
			float64(v.XTPMemoryUsedKB*1024),
			sqlInstance, dbName,
		)
	}
	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerGeneralStatistics docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-general-statistics-object
type win32PerfRawDataSQLServerGeneralStatistics struct {
	ActiveTempTables              uint64
	ConnectionResetPersec         uint64
	EventNotificationsDelayedDrop uint64
	HTTPAuthenticatedRequests     uint64
	LogicalConnections            uint64
	LoginsPersec                  uint64
	LogoutsPersec                 uint64
	MarsDeadlocks                 uint64
	Nonatomicyieldrate            uint64
	Processesblocked              uint64
	SOAPEmptyRequests             uint64
	SOAPMethodInvocations         uint64
	SOAPSessionInitiateRequests   uint64
	SOAPSessionTerminateRequests  uint64
	SOAPSQLRequests               uint64
	SOAPWSDLRequests              uint64
	SQLTraceIOProviderLockWaits   uint64
	Tempdbrecoveryunitid          uint64
	Tempdbrowsetid                uint64
	TempTablesCreationRate        uint64
	TempTablesForDestruction      uint64
	TraceEventNotificationQueue   uint64
	Transactions                  uint64
	UserConnections               uint64
}

func (c *MSSQLCollector) collectGeneralStatistics(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerGeneralStatistics
	log.Debugf("mssql_genstats collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("GeneralStatistics", sqlInstance)
	q := queryAllForClass(&dst, class)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}
	if len(dst) == 0 {
		return nil, errors.New("WMI query returned empty result set")
	}

	v := dst[0]
	ch <- prometheus.MustNewConstMetric(
		c.GenStatsActiveTempTables,
		prometheus.GaugeValue,
		float64(v.ActiveTempTables),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsConnectionReset,
		prometheus.CounterValue,
		float64(v.ConnectionResetPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsEventNotificationsDelayedDrop,
		prometheus.GaugeValue,
		float64(v.EventNotificationsDelayedDrop),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsHTTPAuthenticatedRequests,
		prometheus.GaugeValue,
		float64(v.HTTPAuthenticatedRequests),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsLogicalConnections,
		prometheus.GaugeValue,
		float64(v.LogicalConnections),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsLogins,
		prometheus.CounterValue,
		float64(v.LoginsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsLogouts,
		prometheus.CounterValue,
		float64(v.LogoutsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsMarsDeadlocks,
		prometheus.GaugeValue,
		float64(v.MarsDeadlocks),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsNonatomicyieldrate,
		prometheus.CounterValue,
		float64(v.Nonatomicyieldrate),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsProcessesblocked,
		prometheus.GaugeValue,
		float64(v.Processesblocked),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsSOAPEmptyRequests,
		prometheus.GaugeValue,
		float64(v.SOAPEmptyRequests),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsSOAPMethodInvocations,
		prometheus.GaugeValue,
		float64(v.SOAPMethodInvocations),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsSOAPSessionInitiateRequests,
		prometheus.GaugeValue,
		float64(v.SOAPSessionInitiateRequests),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsSOAPSessionTerminateRequests,
		prometheus.GaugeValue,
		float64(v.SOAPSessionTerminateRequests),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsSOAPSQLRequests,
		prometheus.GaugeValue,
		float64(v.SOAPSQLRequests),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsSOAPWSDLRequests,
		prometheus.GaugeValue,
		float64(v.SOAPWSDLRequests),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsSQLTraceIOProviderLockWaits,
		prometheus.GaugeValue,
		float64(v.SQLTraceIOProviderLockWaits),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsTempdbrecoveryunitid,
		prometheus.GaugeValue,
		float64(v.Tempdbrecoveryunitid),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsTempdbrowsetid,
		prometheus.GaugeValue,
		float64(v.Tempdbrowsetid),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsTempTablesCreationRate,
		prometheus.CounterValue,
		float64(v.TempTablesCreationRate),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsTempTablesForDestruction,
		prometheus.GaugeValue,
		float64(v.TempTablesForDestruction),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsTraceEventNotificationQueue,
		prometheus.GaugeValue,
		float64(v.TraceEventNotificationQueue),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsTransactions,
		prometheus.GaugeValue,
		float64(v.Transactions),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.GenStatsUserConnections,
		prometheus.GaugeValue,
		float64(v.UserConnections),
		sqlInstance,
	)

	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerLocks docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-locks-object
type win32PerfRawDataSQLServerLocks struct {
	Name                       string
	AverageWaitTimems          uint64
	LockRequestsPersec         uint64
	LockTimeoutsPersec         uint64
	LockTimeoutstimeout0Persec uint64
	LockWaitsPersec            uint64
	LockWaitTimems             uint64
	NumberofDeadlocksPersec    uint64
}

func (c *MSSQLCollector) collectLocks(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerLocks
	log.Debugf("mssql_locks collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("Locks", sqlInstance)
	q := queryAllForClassWhere(&dst, class, `Name <> '_Total'`)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	for _, v := range dst {
		lockResourceName := v.Name

		ch <- prometheus.MustNewConstMetric(
			c.LocksAverageWaitTimems,
			prometheus.GaugeValue,
			float64(v.AverageWaitTimems)/1000.0,
			sqlInstance, lockResourceName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.LocksLockRequests,
			prometheus.CounterValue,
			float64(v.LockRequestsPersec),
			sqlInstance, lockResourceName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.LocksLockTimeouts,
			prometheus.CounterValue,
			float64(v.LockTimeoutsPersec),
			sqlInstance, lockResourceName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.LocksLockTimeoutstimeout0,
			prometheus.CounterValue,
			float64(v.LockTimeoutstimeout0Persec),
			sqlInstance, lockResourceName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.LocksLockWaits,
			prometheus.CounterValue,
			float64(v.LockWaitsPersec),
			sqlInstance, lockResourceName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.LocksLockWaitTimems,
			prometheus.GaugeValue,
			float64(v.LockWaitTimems)/1000.0,
			sqlInstance, lockResourceName,
		)

		ch <- prometheus.MustNewConstMetric(
			c.LocksNumberofDeadlocks,
			prometheus.CounterValue,
			float64(v.NumberofDeadlocksPersec),
			sqlInstance, lockResourceName,
		)
	}
	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerMemoryManager docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-memory-manager-object
type win32PerfRawDataSQLServerMemoryManager struct {
	ConnectionMemoryKB       uint64
	DatabaseCacheMemoryKB    uint64
	Externalbenefitofmemory  uint64
	FreeMemoryKB             uint64
	GrantedWorkspaceMemoryKB uint64
	LockBlocks               uint64
	LockBlocksAllocated      uint64
	LockMemoryKB             uint64
	LockOwnerBlocks          uint64
	LockOwnerBlocksAllocated uint64
	LogPoolMemoryKB          uint64
	MaximumWorkspaceMemoryKB uint64
	MemoryGrantsOutstanding  uint64
	MemoryGrantsPending      uint64
	OptimizerMemoryKB        uint64
	ReservedServerMemoryKB   uint64
	SQLCacheMemoryKB         uint64
	StolenServerMemoryKB     uint64
	TargetServerMemoryKB     uint64
	TotalServerMemoryKB      uint64
}

func (c *MSSQLCollector) collectMemoryManager(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerMemoryManager
	log.Debugf("mssql_memmgr collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("MemoryManager", sqlInstance)
	q := queryAllForClass(&dst, class)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}
	if len(dst) == 0 {
		return nil, errors.New("WMI query returned empty result set")
	}

	v := dst[0]

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrConnectionMemoryKB,
		prometheus.GaugeValue,
		float64(v.ConnectionMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrDatabaseCacheMemoryKB,
		prometheus.GaugeValue,
		float64(v.DatabaseCacheMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrExternalbenefitofmemory,
		prometheus.GaugeValue,
		float64(v.Externalbenefitofmemory),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrFreeMemoryKB,
		prometheus.GaugeValue,
		float64(v.FreeMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrGrantedWorkspaceMemoryKB,
		prometheus.GaugeValue,
		float64(v.GrantedWorkspaceMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrLockBlocks,
		prometheus.GaugeValue,
		float64(v.LockBlocks),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrLockBlocksAllocated,
		prometheus.GaugeValue,
		float64(v.LockBlocksAllocated),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrLockMemoryKB,
		prometheus.GaugeValue,
		float64(v.LockMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrLockOwnerBlocks,
		prometheus.GaugeValue,
		float64(v.LockOwnerBlocks),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrLockOwnerBlocksAllocated,
		prometheus.GaugeValue,
		float64(v.LockOwnerBlocksAllocated),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrLogPoolMemoryKB,
		prometheus.GaugeValue,
		float64(v.LogPoolMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrMaximumWorkspaceMemoryKB,
		prometheus.GaugeValue,
		float64(v.MaximumWorkspaceMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrMemoryGrantsOutstanding,
		prometheus.GaugeValue,
		float64(v.MemoryGrantsOutstanding),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrMemoryGrantsPending,
		prometheus.GaugeValue,
		float64(v.MemoryGrantsPending),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrOptimizerMemoryKB,
		prometheus.GaugeValue,
		float64(v.OptimizerMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrReservedServerMemoryKB,
		prometheus.GaugeValue,
		float64(v.ReservedServerMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrSQLCacheMemoryKB,
		prometheus.GaugeValue,
		float64(v.SQLCacheMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrStolenServerMemoryKB,
		prometheus.GaugeValue,
		float64(v.StolenServerMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrTargetServerMemoryKB,
		prometheus.GaugeValue,
		float64(v.TargetServerMemoryKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.MemMgrTotalServerMemoryKB,
		prometheus.GaugeValue,
		float64(v.TotalServerMemoryKB*1024),
		sqlInstance,
	)

	return nil, nil
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerSQLStatistics docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-statistics-object
type win32PerfRawDataSQLServerSQLStatistics struct {
	AutoParamAttemptsPersec       uint64
	BatchRequestsPersec           uint64
	FailedAutoParamsPersec        uint64
	ForcedParameterizationsPersec uint64
	GuidedplanexecutionsPersec    uint64
	MisguidedplanexecutionsPersec uint64
	SafeAutoParamsPersec          uint64
	SQLAttentionrate              uint64
	SQLCompilationsPersec         uint64
	SQLReCompilationsPersec       uint64
	UnsafeAutoParamsPersec        uint64
}

func (c *MSSQLCollector) collectSQLStats(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerSQLStatistics
	log.Debugf("mssql_sqlstats collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("SQLStatistics", sqlInstance)
	q := queryAllForClass(&dst, class)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	if len(dst) == 0 {
		return nil, errors.New("WMI query returned empty result set")
	}

	v := dst[0]

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsAutoParamAttempts,
		prometheus.CounterValue,
		float64(v.AutoParamAttemptsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsBatchRequests,
		prometheus.CounterValue,
		float64(v.BatchRequestsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsFailedAutoParams,
		prometheus.CounterValue,
		float64(v.FailedAutoParamsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsForcedParameterizations,
		prometheus.CounterValue,
		float64(v.ForcedParameterizationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsGuidedplanexecutions,
		prometheus.CounterValue,
		float64(v.GuidedplanexecutionsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsMisguidedplanexecutions,
		prometheus.CounterValue,
		float64(v.MisguidedplanexecutionsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsSafeAutoParams,
		prometheus.CounterValue,
		float64(v.SafeAutoParamsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsSQLAttentionrate,
		prometheus.CounterValue,
		float64(v.SQLAttentionrate),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsSQLCompilations,
		prometheus.CounterValue,
		float64(v.SQLCompilationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsSQLReCompilations,
		prometheus.CounterValue,
		float64(v.SQLReCompilationsPersec),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.SQLStatsUnsafeAutoParams,
		prometheus.CounterValue,
		float64(v.UnsafeAutoParamsPersec),
		sqlInstance,
	)

	return nil, nil
}

type win32PerfRawDataSQLServerSQLErrors struct {
	Name         string
	ErrorsPersec uint64
}

// Win32_PerfRawData_MSSQLSERVER_SQLServerErrors docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-sql-errors-object
func (c *MSSQLCollector) collectSQLErrors(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSQLServerSQLErrors
	log.Debugf("mssql_sqlerrors collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("SQLErrors", sqlInstance)
	q := queryAllForClassWhere(&dst, class, `Name <> '_Total'`)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	for _, v := range dst {
		resource := v.Name

		ch <- prometheus.MustNewConstMetric(
			c.SQLErrorsTotal,
			prometheus.CounterValue,
			float64(v.ErrorsPersec),
			sqlInstance, resource,
		)
	}

	return nil, nil
}

type win32PerfRawDataSqlServerTransactions struct {
	FreeSpaceintempdbKB            uint64
	LongestTransactionRunningTime  uint64
	NonSnapshotVersionTransactions uint64
	SnapshotTransactions           uint64
	Transactions                   uint64
	Updateconflictratio            uint64
	UpdateSnapshotTransactions     uint64
	VersionCleanuprateKBPers       uint64
	VersionGenerationrateKBPers    uint64
	VersionStoreSizeKB             uint64
	VersionStoreunitcount          uint64
	VersionStoreunitcreation       uint64
	VersionStoreunittruncation     uint64
}

// Win32_PerfRawData_MSSQLSERVER_Transactions docs:
// - https://docs.microsoft.com/en-us/sql/relational-databases/performance-monitor/sql-server-transactions-object
func (c *MSSQLCollector) collectTransactions(ch chan<- prometheus.Metric, sqlInstance string) (*prometheus.Desc, error) {
	var dst []win32PerfRawDataSqlServerTransactions
	log.Debugf("mssql_transactions collector iterating sql instance %s.", sqlInstance)

	class := mssqlBuildWMIInstanceClass("Transactions", sqlInstance)
	q := queryAllForClass(&dst, class)
	if err := wmi.Query(q, &dst); err != nil {
		return nil, err
	}

	if len(dst) == 0 {
		return nil, errors.New("WMI query returned empty result set")
	}

	v := dst[0]

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsTempDbFreeSpaceBytes,
		prometheus.GaugeValue,
		float64(v.FreeSpaceintempdbKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsLongestTransactionRunningSeconds,
		prometheus.GaugeValue,
		float64(v.LongestTransactionRunningTime),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsNonSnapshotVersionActiveTotal,
		prometheus.CounterValue,
		float64(v.NonSnapshotVersionTransactions),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsSnapshotActiveTotal,
		prometheus.CounterValue,
		float64(v.SnapshotTransactions),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsActiveTotal,
		prometheus.CounterValue,
		float64(v.Transactions),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsUpdateConflictsTotal,
		prometheus.CounterValue,
		float64(v.Updateconflictratio),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsUpdateSnapshotActiveTotal,
		prometheus.CounterValue,
		float64(v.UpdateSnapshotTransactions),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsVersionCleanupRateBytes,
		prometheus.GaugeValue,
		float64(v.VersionCleanuprateKBPers*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsVersionGenerationRateBytes,
		prometheus.GaugeValue,
		float64(v.VersionGenerationrateKBPers*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsVersionStoreSizeBytes,
		prometheus.GaugeValue,
		float64(v.VersionStoreSizeKB*1024),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsVersionStoreUnits,
		prometheus.CounterValue,
		float64(v.VersionStoreunitcount),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsVersionStoreCreationUnits,
		prometheus.CounterValue,
		float64(v.VersionStoreunitcreation),
		sqlInstance,
	)

	ch <- prometheus.MustNewConstMetric(
		c.TransactionsVersionStoreTruncationUnits,
		prometheus.CounterValue,
		float64(v.VersionStoreunittruncation),
		sqlInstance,
	)

	return nil, nil
}