diff --git a/collector/arp_linux.go b/collector/arp_linux.go
index c3d4715163..84d8920ad5 100644
--- a/collector/arp_linux.go
+++ b/collector/arp_linux.go
@@ -35,7 +35,6 @@ var (
 type arpCollector struct {
 	fs           procfs.FS
 	deviceFilter deviceFilter
-	entries      *prometheus.Desc
 	logger       *slog.Logger
 }
 
@@ -43,6 +42,14 @@ func init() {
 	registerCollector("arp", defaultEnabled, NewARPCollector)
 }
 
+var (
+	arpEntries = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "arp", "entries"),
+		"ARP entries by device",
+		[]string{"device"}, nil,
+	)
+)
+
 // NewARPCollector returns a new Collector exposing ARP stats.
 func NewARPCollector(logger *slog.Logger) (Collector, error) {
 	fs, err := procfs.NewFS(*procPath)
@@ -53,12 +60,7 @@ func NewARPCollector(logger *slog.Logger) (Collector, error) {
 	return &arpCollector{
 		fs:           fs,
 		deviceFilter: newDeviceFilter(*arpDeviceExclude, *arpDeviceInclude),
-		entries: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "arp", "entries"),
-			"ARP entries by device",
-			[]string{"device"}, nil,
-		),
-		logger: logger,
+		logger:       logger,
 	}, nil
 }
 
@@ -123,7 +125,7 @@ func (c *arpCollector) Update(ch chan<- prometheus.Metric) error {
 			continue
 		}
 		ch <- prometheus.MustNewConstMetric(
-			c.entries, prometheus.GaugeValue, float64(entryCount), device)
+			arpEntries, prometheus.GaugeValue, float64(entryCount), device)
 	}
 
 	return nil
diff --git a/collector/buddyinfo.go b/collector/buddyinfo.go
index e0b54fb36b..82c58c32f2 100644
--- a/collector/buddyinfo.go
+++ b/collector/buddyinfo.go
@@ -30,7 +30,6 @@ const (
 
 type buddyinfoCollector struct {
 	fs     procfs.FS
-	desc   *prometheus.Desc
 	logger *slog.Logger
 }
 
@@ -38,18 +37,21 @@ func init() {
 	registerCollector("buddyinfo", defaultDisabled, NewBuddyinfoCollector)
 }
 
-// NewBuddyinfoCollector returns a new Collector exposing buddyinfo stats.
-func NewBuddyinfoCollector(logger *slog.Logger) (Collector, error) {
-	desc := prometheus.NewDesc(
+var (
+	buddyinfoBlocks = prometheus.NewDesc(
 		prometheus.BuildFQName(namespace, buddyInfoSubsystem, "blocks"),
 		"Count of free blocks according to size.",
 		[]string{"node", "zone", "size"}, nil,
 	)
+)
+
+// NewBuddyinfoCollector returns a new Collector exposing buddyinfo stats.
+func NewBuddyinfoCollector(logger *slog.Logger) (Collector, error) {
 	fs, err := procfs.NewFS(*procPath)
 	if err != nil {
 		return nil, fmt.Errorf("failed to open procfs: %w", err)
 	}
-	return &buddyinfoCollector{fs, desc, logger}, nil
+	return &buddyinfoCollector{fs, logger}, nil
 }
 
 // Update calls (*buddyinfoCollector).getBuddyInfo to get the platform specific
@@ -64,7 +66,7 @@ func (c *buddyinfoCollector) Update(ch chan<- prometheus.Metric) error {
 	for _, entry := range buddyInfo {
 		for size, value := range entry.Sizes {
 			ch <- prometheus.MustNewConstMetric(
-				c.desc,
+				buddyinfoBlocks,
 				prometheus.GaugeValue, value,
 				entry.Node, entry.Zone, strconv.Itoa(size),
 			)
diff --git a/collector/cgroups_linux.go b/collector/cgroups_linux.go
index f8da892ee4..adede992ea 100644
--- a/collector/cgroups_linux.go
+++ b/collector/cgroups_linux.go
@@ -26,16 +26,27 @@ import (
 const cgroupsCollectorSubsystem = "cgroups"
 
 type cgroupSummaryCollector struct {
-	fs      procfs.FS
-	cgroups *prometheus.Desc
-	enabled *prometheus.Desc
-	logger  *slog.Logger
+	fs     procfs.FS
+	logger *slog.Logger
 }
 
 func init() {
 	registerCollector(cgroupsCollectorSubsystem, defaultDisabled, NewCgroupSummaryCollector)
 }
 
+var (
+	cgroupsCgroups = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, cgroupsCollectorSubsystem, "cgroups"),
+		"Current cgroup number of the subsystem.",
+		[]string{"subsys_name"}, nil,
+	)
+	cgroupsEnabled = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, cgroupsCollectorSubsystem, "enabled"),
+		"Current cgroup number of the subsystem.",
+		[]string{"subsys_name"}, nil,
+	)
+)
+
 // NewCgroupSummaryCollector returns a new Collector exposing a summary of cgroups.
 func NewCgroupSummaryCollector(logger *slog.Logger) (Collector, error) {
 	fs, err := procfs.NewFS(*procPath)
@@ -43,17 +54,7 @@ func NewCgroupSummaryCollector(logger *slog.Logger) (Collector, error) {
 		return nil, fmt.Errorf("failed to open procfs: %w", err)
 	}
 	return &cgroupSummaryCollector{
-		fs: fs,
-		cgroups: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, cgroupsCollectorSubsystem, "cgroups"),
-			"Current cgroup number of the subsystem.",
-			[]string{"subsys_name"}, nil,
-		),
-		enabled: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, cgroupsCollectorSubsystem, "enabled"),
-			"Current cgroup number of the subsystem.",
-			[]string{"subsys_name"}, nil,
-		),
+		fs:     fs,
 		logger: logger,
 	}, nil
 }
@@ -65,8 +66,8 @@ func (c *cgroupSummaryCollector) Update(ch chan<- prometheus.Metric) error {
 		return err
 	}
 	for _, cs := range cgroupSummarys {
-		ch <- prometheus.MustNewConstMetric(c.cgroups, prometheus.GaugeValue, float64(cs.Cgroups), cs.SubsysName)
-		ch <- prometheus.MustNewConstMetric(c.enabled, prometheus.GaugeValue, float64(cs.Enabled), cs.SubsysName)
+		ch <- prometheus.MustNewConstMetric(cgroupsCgroups, prometheus.GaugeValue, float64(cs.Cgroups), cs.SubsysName)
+		ch <- prometheus.MustNewConstMetric(cgroupsEnabled, prometheus.GaugeValue, float64(cs.Enabled), cs.SubsysName)
 	}
 	return nil
 }
diff --git a/collector/conntrack_linux.go b/collector/conntrack_linux.go
index 376ab05af5..eeeb7d4bd9 100644
--- a/collector/conntrack_linux.go
+++ b/collector/conntrack_linux.go
@@ -26,17 +26,7 @@ import (
 )
 
 type conntrackCollector struct {
-	current       *prometheus.Desc
-	limit         *prometheus.Desc
-	found         *prometheus.Desc
-	invalid       *prometheus.Desc
-	ignore        *prometheus.Desc
-	insert        *prometheus.Desc
-	insertFailed  *prometheus.Desc
-	drop          *prometheus.Desc
-	earlyDrop     *prometheus.Desc
-	searchRestart *prometheus.Desc
-	logger        *slog.Logger
+	logger *slog.Logger
 }
 
 type conntrackStatistics struct {
@@ -54,59 +44,62 @@ func init() {
 	registerCollector("conntrack", defaultEnabled, NewConntrackCollector)
 }
 
+var (
+	conntrackCurrent = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_entries"),
+		"Number of currently allocated flow entries for connection tracking.",
+		nil, nil,
+	)
+	conntrackLimit = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_entries_limit"),
+		"Maximum size of connection tracking table.",
+		nil, nil,
+	)
+	conntrackFound = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_found"),
+		"Number of searched entries which were successful.",
+		nil, nil,
+	)
+	conntrackInvalid = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_invalid"),
+		"Number of packets seen which can not be tracked.",
+		nil, nil,
+	)
+	conntrackIgnore = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_ignore"),
+		"Number of packets seen which are already connected to a conntrack entry.",
+		nil, nil,
+	)
+	conntrackInsert = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_insert"),
+		"Number of entries inserted into the list.",
+		nil, nil,
+	)
+	conntrackInsertFailed = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_insert_failed"),
+		"Number of entries for which list insertion was attempted but failed.",
+		nil, nil,
+	)
+	conntrackDrop = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_drop"),
+		"Number of packets dropped due to conntrack failure.",
+		nil, nil,
+	)
+	conntrackEarlyDrop = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_early_drop"),
+		"Number of dropped conntrack entries to make room for new ones, if maximum table size was reached.",
+		nil, nil,
+	)
+	conntrackSearchRestart = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_search_restart"),
+		"Number of conntrack table lookups which had to be restarted due to hashtable resizes.",
+		nil, nil,
+	)
+)
+
 // NewConntrackCollector returns a new Collector exposing conntrack stats.
 func NewConntrackCollector(logger *slog.Logger) (Collector, error) {
 	return &conntrackCollector{
-		current: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_entries"),
-			"Number of currently allocated flow entries for connection tracking.",
-			nil, nil,
-		),
-		limit: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_entries_limit"),
-			"Maximum size of connection tracking table.",
-			nil, nil,
-		),
-		found: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_found"),
-			"Number of searched entries which were successful.",
-			nil, nil,
-		),
-		invalid: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_invalid"),
-			"Number of packets seen which can not be tracked.",
-			nil, nil,
-		),
-		ignore: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_ignore"),
-			"Number of packets seen which are already connected to a conntrack entry.",
-			nil, nil,
-		),
-		insert: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_insert"),
-			"Number of entries inserted into the list.",
-			nil, nil,
-		),
-		insertFailed: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_insert_failed"),
-			"Number of entries for which list insertion was attempted but failed.",
-			nil, nil,
-		),
-		drop: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_drop"),
-			"Number of packets dropped due to conntrack failure.",
-			nil, nil,
-		),
-		earlyDrop: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_early_drop"),
-			"Number of dropped conntrack entries to make room for new ones, if maximum table size was reached.",
-			nil, nil,
-		),
-		searchRestart: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "nf_conntrack_stat_search_restart"),
-			"Number of conntrack table lookups which had to be restarted due to hashtable resizes.",
-			nil, nil,
-		),
 		logger: logger,
 	}, nil
 }
@@ -117,14 +110,14 @@ func (c *conntrackCollector) Update(ch chan<- prometheus.Metric) error {
 		return c.handleErr(err)
 	}
 	ch <- prometheus.MustNewConstMetric(
-		c.current, prometheus.GaugeValue, float64(value))
+		conntrackCurrent, prometheus.GaugeValue, float64(value))
 
 	value, err = readUintFromFile(procFilePath("sys/net/netfilter/nf_conntrack_max"))
 	if err != nil {
 		return c.handleErr(err)
 	}
 	ch <- prometheus.MustNewConstMetric(
-		c.limit, prometheus.GaugeValue, float64(value))
+		conntrackLimit, prometheus.GaugeValue, float64(value))
 
 	conntrackStats, err := getConntrackStatistics()
 	if err != nil {
@@ -132,21 +125,21 @@ func (c *conntrackCollector) Update(ch chan<- prometheus.Metric) error {
 	}
 
 	ch <- prometheus.MustNewConstMetric(
-		c.found, prometheus.GaugeValue, float64(conntrackStats.found))
+		conntrackFound, prometheus.GaugeValue, float64(conntrackStats.found))
 	ch <- prometheus.MustNewConstMetric(
-		c.invalid, prometheus.GaugeValue, float64(conntrackStats.invalid))
+		conntrackInvalid, prometheus.GaugeValue, float64(conntrackStats.invalid))
 	ch <- prometheus.MustNewConstMetric(
-		c.ignore, prometheus.GaugeValue, float64(conntrackStats.ignore))
+		conntrackIgnore, prometheus.GaugeValue, float64(conntrackStats.ignore))
 	ch <- prometheus.MustNewConstMetric(
-		c.insert, prometheus.GaugeValue, float64(conntrackStats.insert))
+		conntrackInsert, prometheus.GaugeValue, float64(conntrackStats.insert))
 	ch <- prometheus.MustNewConstMetric(
-		c.insertFailed, prometheus.GaugeValue, float64(conntrackStats.insertFailed))
+		conntrackInsertFailed, prometheus.GaugeValue, float64(conntrackStats.insertFailed))
 	ch <- prometheus.MustNewConstMetric(
-		c.drop, prometheus.GaugeValue, float64(conntrackStats.drop))
+		conntrackDrop, prometheus.GaugeValue, float64(conntrackStats.drop))
 	ch <- prometheus.MustNewConstMetric(
-		c.earlyDrop, prometheus.GaugeValue, float64(conntrackStats.earlyDrop))
+		conntrackEarlyDrop, prometheus.GaugeValue, float64(conntrackStats.earlyDrop))
 	ch <- prometheus.MustNewConstMetric(
-		c.searchRestart, prometheus.GaugeValue, float64(conntrackStats.searchRestart))
+		conntrackSearchRestart, prometheus.GaugeValue, float64(conntrackStats.searchRestart))
 	return nil
 }
 
@@ -159,7 +152,7 @@ func (c *conntrackCollector) handleErr(err error) error {
 }
 
 func getConntrackStatistics() (*conntrackStatistics, error) {
-	c := conntrackStatistics{}
+	s := conntrackStatistics{}
 
 	fs, err := procfs.NewFS(*procPath)
 	if err != nil {
@@ -172,15 +165,15 @@ func getConntrackStatistics() (*conntrackStatistics, error) {
 	}
 
 	for _, connStat := range connStats {
-		c.found += connStat.Found
-		c.invalid += connStat.Invalid
-		c.ignore += connStat.Ignore
-		c.insert += connStat.Insert
-		c.insertFailed += connStat.InsertFailed
-		c.drop += connStat.Drop
-		c.earlyDrop += connStat.EarlyDrop
-		c.searchRestart += connStat.SearchRestart
+		s.found += connStat.Found
+		s.invalid += connStat.Invalid
+		s.ignore += connStat.Ignore
+		s.insert += connStat.Insert
+		s.insertFailed += connStat.InsertFailed
+		s.drop += connStat.Drop
+		s.earlyDrop += connStat.EarlyDrop
+		s.searchRestart += connStat.SearchRestart
 	}
 
-	return &c, nil
+	return &s, nil
 }
diff --git a/collector/drm_linux.go b/collector/drm_linux.go
index 80356ee84c..6c19514c4f 100644
--- a/collector/drm_linux.go
+++ b/collector/drm_linux.go
@@ -28,22 +28,57 @@ const (
 )
 
 type drmCollector struct {
-	fs                    sysfs.FS
-	logger                *slog.Logger
-	CardInfo              *prometheus.Desc
-	GPUBusyPercent        *prometheus.Desc
-	MemoryGTTSize         *prometheus.Desc
-	MemoryGTTUsed         *prometheus.Desc
-	MemoryVisibleVRAMSize *prometheus.Desc
-	MemoryVisibleVRAMUsed *prometheus.Desc
-	MemoryVRAMSize        *prometheus.Desc
-	MemoryVRAMUsed        *prometheus.Desc
+	fs     sysfs.FS
+	logger *slog.Logger
 }
 
 func init() {
 	registerCollector("drm", defaultDisabled, NewDrmCollector)
 }
 
+var (
+	drmCardInfo = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "card_info"),
+		"Card information",
+		[]string{"card", "memory_vendor", "power_performance_level", "unique_id", "vendor"}, nil,
+	)
+	drmGPUBusyPercent = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "gpu_busy_percent"),
+		"How busy the GPU is as a percentage.",
+		[]string{"card"}, nil,
+	)
+	drmMemoryGTTSize = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_gtt_size_bytes"),
+		"The size of the graphics translation table (GTT) block in bytes.",
+		[]string{"card"}, nil,
+	)
+	drmMemoryGTTUsed = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_gtt_used_bytes"),
+		"The used amount of the graphics translation table (GTT) block in bytes.",
+		[]string{"card"}, nil,
+	)
+	drmMemoryVisibleVRAMSize = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vis_vram_size_bytes"),
+		"The size of visible VRAM in bytes.",
+		[]string{"card"}, nil,
+	)
+	drmMemoryVisibleVRAMUsed = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vis_vram_used_bytes"),
+		"The used amount of visible VRAM in bytes.",
+		[]string{"card"}, nil,
+	)
+	drmMemoryVRAMSize = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vram_size_bytes"),
+		"The size of VRAM in bytes.",
+		[]string{"card"}, nil,
+	)
+	drmMemoryVRAMUsed = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vram_used_bytes"),
+		"The used amount of VRAM in bytes.",
+		[]string{"card"}, nil,
+	)
+)
+
 // NewDrmCollector returns a new Collector exposing /sys/class/drm/card?/device stats.
 func NewDrmCollector(logger *slog.Logger) (Collector, error) {
 	fs, err := sysfs.NewFS(*sysPath)
@@ -54,46 +89,6 @@ func NewDrmCollector(logger *slog.Logger) (Collector, error) {
 	return &drmCollector{
 		fs:     fs,
 		logger: logger,
-		CardInfo: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "card_info"),
-			"Card information",
-			[]string{"card", "memory_vendor", "power_performance_level", "unique_id", "vendor"}, nil,
-		),
-		GPUBusyPercent: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "gpu_busy_percent"),
-			"How busy the GPU is as a percentage.",
-			[]string{"card"}, nil,
-		),
-		MemoryGTTSize: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_gtt_size_bytes"),
-			"The size of the graphics translation table (GTT) block in bytes.",
-			[]string{"card"}, nil,
-		),
-		MemoryGTTUsed: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_gtt_used_bytes"),
-			"The used amount of the graphics translation table (GTT) block in bytes.",
-			[]string{"card"}, nil,
-		),
-		MemoryVisibleVRAMSize: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vis_vram_size_bytes"),
-			"The size of visible VRAM in bytes.",
-			[]string{"card"}, nil,
-		),
-		MemoryVisibleVRAMUsed: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vis_vram_used_bytes"),
-			"The used amount of visible VRAM in bytes.",
-			[]string{"card"}, nil,
-		),
-		MemoryVRAMSize: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vram_size_bytes"),
-			"The size of VRAM in bytes.",
-			[]string{"card"}, nil,
-		),
-		MemoryVRAMUsed: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, drmCollectorSubsystem, "memory_vram_used_bytes"),
-			"The used amount of VRAM in bytes.",
-			[]string{"card"}, nil,
-		),
 	}, nil
 }
 
@@ -110,29 +105,29 @@ func (c *drmCollector) updateAMDCards(ch chan<- prometheus.Metric) error {
 
 	for _, s := range stats {
 		ch <- prometheus.MustNewConstMetric(
-			c.CardInfo, prometheus.GaugeValue, 1,
+			drmCardInfo, prometheus.GaugeValue, 1,
 			s.Name, s.MemoryVRAMVendor, s.PowerDPMForcePerformanceLevel, s.UniqueID, vendor)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.GPUBusyPercent, prometheus.GaugeValue, float64(s.GPUBusyPercent), s.Name)
+			drmGPUBusyPercent, prometheus.GaugeValue, float64(s.GPUBusyPercent), s.Name)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.MemoryGTTSize, prometheus.GaugeValue, float64(s.MemoryGTTSize), s.Name)
+			drmMemoryGTTSize, prometheus.GaugeValue, float64(s.MemoryGTTSize), s.Name)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.MemoryGTTUsed, prometheus.GaugeValue, float64(s.MemoryGTTUsed), s.Name)
+			drmMemoryGTTUsed, prometheus.GaugeValue, float64(s.MemoryGTTUsed), s.Name)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.MemoryVRAMSize, prometheus.GaugeValue, float64(s.MemoryVRAMSize), s.Name)
+			drmMemoryVRAMSize, prometheus.GaugeValue, float64(s.MemoryVRAMSize), s.Name)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.MemoryVRAMUsed, prometheus.GaugeValue, float64(s.MemoryVRAMUsed), s.Name)
+			drmMemoryVRAMUsed, prometheus.GaugeValue, float64(s.MemoryVRAMUsed), s.Name)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.MemoryVisibleVRAMSize, prometheus.GaugeValue, float64(s.MemoryVisibleVRAMSize), s.Name)
+			drmMemoryVisibleVRAMSize, prometheus.GaugeValue, float64(s.MemoryVisibleVRAMSize), s.Name)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.MemoryVisibleVRAMUsed, prometheus.GaugeValue, float64(s.MemoryVisibleVRAMUsed), s.Name)
+			drmMemoryVisibleVRAMUsed, prometheus.GaugeValue, float64(s.MemoryVisibleVRAMUsed), s.Name)
 	}
 
 	return nil
diff --git a/collector/edac_linux.go b/collector/edac_linux.go
index d3a2a07a83..e86062fb10 100644
--- a/collector/edac_linux.go
+++ b/collector/edac_linux.go
@@ -34,40 +34,39 @@ var (
 )
 
 type edacCollector struct {
-	ceCount      *prometheus.Desc
-	ueCount      *prometheus.Desc
-	csRowCECount *prometheus.Desc
-	csRowUECount *prometheus.Desc
-	logger       *slog.Logger
+	logger *slog.Logger
 }
 
 func init() {
 	registerCollector("edac", defaultEnabled, NewEdacCollector)
 }
 
+var (
+	edacCeCount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, edacSubsystem, "correctable_errors_total"),
+		"Total correctable memory errors.",
+		[]string{"controller"}, nil,
+	)
+	edacUeCount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, edacSubsystem, "uncorrectable_errors_total"),
+		"Total uncorrectable memory errors.",
+		[]string{"controller"}, nil,
+	)
+	edacCsRowCECount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, edacSubsystem, "csrow_correctable_errors_total"),
+		"Total correctable memory errors for this csrow.",
+		[]string{"controller", "csrow"}, nil,
+	)
+	edacCsRowUECount = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, edacSubsystem, "csrow_uncorrectable_errors_total"),
+		"Total uncorrectable memory errors for this csrow.",
+		[]string{"controller", "csrow"}, nil,
+	)
+)
+
 // NewEdacCollector returns a new Collector exposing edac stats.
 func NewEdacCollector(logger *slog.Logger) (Collector, error) {
 	return &edacCollector{
-		ceCount: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, edacSubsystem, "correctable_errors_total"),
-			"Total correctable memory errors.",
-			[]string{"controller"}, nil,
-		),
-		ueCount: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, edacSubsystem, "uncorrectable_errors_total"),
-			"Total uncorrectable memory errors.",
-			[]string{"controller"}, nil,
-		),
-		csRowCECount: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, edacSubsystem, "csrow_correctable_errors_total"),
-			"Total correctable memory errors for this csrow.",
-			[]string{"controller", "csrow"}, nil,
-		),
-		csRowUECount: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, edacSubsystem, "csrow_uncorrectable_errors_total"),
-			"Total uncorrectable memory errors for this csrow.",
-			[]string{"controller", "csrow"}, nil,
-		),
 		logger: logger,
 	}, nil
 }
@@ -89,28 +88,28 @@ func (c *edacCollector) Update(ch chan<- prometheus.Metric) error {
 			return fmt.Errorf("couldn't get ce_count for controller %s: %w", controllerNumber, err)
 		}
 		ch <- prometheus.MustNewConstMetric(
-			c.ceCount, prometheus.CounterValue, float64(value), controllerNumber)
+			edacCeCount, prometheus.CounterValue, float64(value), controllerNumber)
 
 		value, err = readUintFromFile(filepath.Join(controller, "ce_noinfo_count"))
 		if err != nil {
 			return fmt.Errorf("couldn't get ce_noinfo_count for controller %s: %w", controllerNumber, err)
 		}
 		ch <- prometheus.MustNewConstMetric(
-			c.csRowCECount, prometheus.CounterValue, float64(value), controllerNumber, "unknown")
+			edacCsRowCECount, prometheus.CounterValue, float64(value), controllerNumber, "unknown")
 
 		value, err = readUintFromFile(filepath.Join(controller, "ue_count"))
 		if err != nil {
 			return fmt.Errorf("couldn't get ue_count for controller %s: %w", controllerNumber, err)
 		}
 		ch <- prometheus.MustNewConstMetric(
-			c.ueCount, prometheus.CounterValue, float64(value), controllerNumber)
+			edacUeCount, prometheus.CounterValue, float64(value), controllerNumber)
 
 		value, err = readUintFromFile(filepath.Join(controller, "ue_noinfo_count"))
 		if err != nil {
 			return fmt.Errorf("couldn't get ue_noinfo_count for controller %s: %w", controllerNumber, err)
 		}
 		ch <- prometheus.MustNewConstMetric(
-			c.csRowUECount, prometheus.CounterValue, float64(value), controllerNumber, "unknown")
+			edacCsRowUECount, prometheus.CounterValue, float64(value), controllerNumber, "unknown")
 
 		// For each controller, walk the csrow directories.
 		csrows, err := filepath.Glob(controller + "/csrow[0-9]*")
@@ -129,14 +128,14 @@ func (c *edacCollector) Update(ch chan<- prometheus.Metric) error {
 				return fmt.Errorf("couldn't get ce_count for controller/csrow %s/%s: %w", controllerNumber, csrowNumber, err)
 			}
 			ch <- prometheus.MustNewConstMetric(
-				c.csRowCECount, prometheus.CounterValue, float64(value), controllerNumber, csrowNumber)
+				edacCsRowCECount, prometheus.CounterValue, float64(value), controllerNumber, csrowNumber)
 
 			value, err = readUintFromFile(filepath.Join(csrow, "ue_count"))
 			if err != nil {
 				return fmt.Errorf("couldn't get ue_count for controller/csrow %s/%s: %w", controllerNumber, csrowNumber, err)
 			}
 			ch <- prometheus.MustNewConstMetric(
-				c.csRowUECount, prometheus.CounterValue, float64(value), controllerNumber, csrowNumber)
+				edacCsRowUECount, prometheus.CounterValue, float64(value), controllerNumber, csrowNumber)
 		}
 	}
 
diff --git a/collector/entropy_linux.go b/collector/entropy_linux.go
index 1373bf3648..8e20981c63 100644
--- a/collector/entropy_linux.go
+++ b/collector/entropy_linux.go
@@ -24,16 +24,27 @@ import (
 )
 
 type entropyCollector struct {
-	fs              procfs.FS
-	entropyAvail    *prometheus.Desc
-	entropyPoolSize *prometheus.Desc
-	logger          *slog.Logger
+	fs     procfs.FS
+	logger *slog.Logger
 }
 
 func init() {
 	registerCollector("entropy", defaultEnabled, NewEntropyCollector)
 }
 
+var (
+	entropyAvail = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "entropy_available_bits"),
+		"Bits of available entropy.",
+		nil, nil,
+	)
+	entropyPoolSize = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "entropy_pool_size_bits"),
+		"Bits of entropy pool.",
+		nil, nil,
+	)
+)
+
 // NewEntropyCollector returns a new Collector exposing entropy stats.
 func NewEntropyCollector(logger *slog.Logger) (Collector, error) {
 	fs, err := procfs.NewFS(*procPath)
@@ -42,17 +53,7 @@ func NewEntropyCollector(logger *slog.Logger) (Collector, error) {
 	}
 
 	return &entropyCollector{
-		fs: fs,
-		entropyAvail: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "entropy_available_bits"),
-			"Bits of available entropy.",
-			nil, nil,
-		),
-		entropyPoolSize: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "entropy_pool_size_bits"),
-			"Bits of entropy pool.",
-			nil, nil,
-		),
+		fs:     fs,
 		logger: logger,
 	}, nil
 }
@@ -67,13 +68,13 @@ func (c *entropyCollector) Update(ch chan<- prometheus.Metric) error {
 		return fmt.Errorf("couldn't get entropy_avail")
 	}
 	ch <- prometheus.MustNewConstMetric(
-		c.entropyAvail, prometheus.GaugeValue, float64(*stats.EntropyAvaliable))
+		entropyAvail, prometheus.GaugeValue, float64(*stats.EntropyAvaliable))
 
 	if stats.PoolSize == nil {
 		return fmt.Errorf("couldn't get entropy poolsize")
 	}
 	ch <- prometheus.MustNewConstMetric(
-		c.entropyPoolSize, prometheus.GaugeValue, float64(*stats.PoolSize))
+		entropyPoolSize, prometheus.GaugeValue, float64(*stats.PoolSize))
 
 	return nil
 }
diff --git a/collector/nvme_linux.go b/collector/nvme_linux.go
index 9cf5a803de..dff757c7bd 100644
--- a/collector/nvme_linux.go
+++ b/collector/nvme_linux.go
@@ -26,72 +26,61 @@ import (
 )
 
 type nvmeCollector struct {
-	fs                             sysfs.FS
-	logger                         *slog.Logger
-	namespaceInfo                  *prometheus.Desc
-	namespaceCapacityBytes         *prometheus.Desc
-	namespaceSizeBytes             *prometheus.Desc
-	namespaceUsedBytes             *prometheus.Desc
-	namespaceLogicalBlockSizeBytes *prometheus.Desc
-	info                           *prometheus.Desc
+	fs     sysfs.FS
+	logger *slog.Logger
 }
 
 func init() {
 	registerCollector("nvme", defaultEnabled, NewNVMeCollector)
 }
 
-// NewNVMeCollector returns a new Collector exposing NVMe stats.
-func NewNVMeCollector(logger *slog.Logger) (Collector, error) {
-	fs, err := sysfs.NewFS(*sysPath)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open sysfs: %w", err)
-	}
-
-	info := prometheus.NewDesc(
+var (
+	nvmeInfo = prometheus.NewDesc(
 		prometheus.BuildFQName(namespace, "nvme", "info"),
 		"Non-numeric data from /sys/class/nvme/<device>, value is always 1.",
 		[]string{"device", "firmware_revision", "model", "serial", "state", "cntlid"},
 		nil,
 	)
-	namespaceInfo := prometheus.NewDesc(
+	nvmeNamespaceInfo = prometheus.NewDesc(
 		prometheus.BuildFQName(namespace, "nvme", "namespace_info"),
 		"Information about NVMe namespaces. Value is always 1",
 		[]string{"device", "nsid", "ana_state"}, nil,
 	)
 
-	namespaceCapacityBytes := prometheus.NewDesc(
+	nvmeNamespaceCapacityBytes = prometheus.NewDesc(
 		prometheus.BuildFQName(namespace, "nvme", "namespace_capacity_bytes"),
 		"Capacity of the NVMe namespace in bytes. Computed as namespace_size * namespace_logical_block_size",
 		[]string{"device", "nsid"}, nil,
 	)
 
-	namespaceSizeBytes := prometheus.NewDesc(
+	nvmeNamespaceSizeBytes = prometheus.NewDesc(
 		prometheus.BuildFQName(namespace, "nvme", "namespace_size_bytes"),
 		"Size of the NVMe namespace in bytes. Available in /sys/class/nvme/<device>/<namespace>/size",
 		[]string{"device", "nsid"}, nil,
 	)
 
-	namespaceUsedBytes := prometheus.NewDesc(
+	nvmeNamespaceUsedBytes = prometheus.NewDesc(
 		prometheus.BuildFQName(namespace, "nvme", "namespace_used_bytes"),
 		"Used space of the NVMe namespace in bytes. Available in /sys/class/nvme/<device>/<namespace>/nuse",
 		[]string{"device", "nsid"}, nil,
 	)
 
-	namespaceLogicalBlockSizeBytes := prometheus.NewDesc(
+	nvmeNamespaceLogicalBlockSizeBytes = prometheus.NewDesc(
 		prometheus.BuildFQName(namespace, "nvme", "namespace_logical_block_size_bytes"),
 		"Logical block size of the NVMe namespace in bytes. Usually 4Kb. Available in /sys/class/nvme/<device>/<namespace>/queue/logical_block_size",
 		[]string{"device", "nsid"}, nil,
 	)
+)
 
+// NewNVMeCollector returns a new Collector exposing NVMe stats.
+func NewNVMeCollector(logger *slog.Logger) (Collector, error) {
+	fs, err := sysfs.NewFS(*sysPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to open sysfs: %w", err)
+	}
 	return &nvmeCollector{
-		fs:                             fs,
-		logger:                         logger,
-		namespaceInfo:                  namespaceInfo,
-		namespaceCapacityBytes:         namespaceCapacityBytes,
-		namespaceSizeBytes:             namespaceSizeBytes,
-		namespaceUsedBytes:             namespaceUsedBytes,
-		namespaceLogicalBlockSizeBytes: namespaceLogicalBlockSizeBytes,
-		info:                           info,
+		fs:     fs,
+		logger: logger,
 	}, nil
 }
 
@@ -108,7 +97,7 @@ func (c *nvmeCollector) Update(ch chan<- prometheus.Metric) error {
 	for _, device := range devices {
 		// Export device-level metrics
 		ch <- prometheus.MustNewConstMetric(
-			c.info,
+			nvmeInfo,
 			prometheus.GaugeValue,
 			1.0,
 			device.Name,
@@ -123,7 +112,7 @@ func (c *nvmeCollector) Update(ch chan<- prometheus.Metric) error {
 		for _, namespace := range device.Namespaces {
 			// Namespace info metric
 			ch <- prometheus.MustNewConstMetric(
-				c.namespaceInfo,
+				nvmeNamespaceInfo,
 				prometheus.GaugeValue,
 				1.0,
 				device.Name,
@@ -133,7 +122,7 @@ func (c *nvmeCollector) Update(ch chan<- prometheus.Metric) error {
 
 			// Namespace capacity in bytes
 			ch <- prometheus.MustNewConstMetric(
-				c.namespaceCapacityBytes,
+				nvmeNamespaceCapacityBytes,
 				prometheus.GaugeValue,
 				float64(namespace.CapacityBytes),
 				device.Name,
@@ -142,7 +131,7 @@ func (c *nvmeCollector) Update(ch chan<- prometheus.Metric) error {
 
 			// Namespace size in bytes
 			ch <- prometheus.MustNewConstMetric(
-				c.namespaceSizeBytes,
+				nvmeNamespaceSizeBytes,
 				prometheus.GaugeValue,
 				float64(namespace.SizeBytes),
 				device.Name,
@@ -151,7 +140,7 @@ func (c *nvmeCollector) Update(ch chan<- prometheus.Metric) error {
 
 			// Namespace used space in bytes
 			ch <- prometheus.MustNewConstMetric(
-				c.namespaceUsedBytes,
+				nvmeNamespaceUsedBytes,
 				prometheus.GaugeValue,
 				float64(namespace.UsedBytes),
 				device.Name,
@@ -160,7 +149,7 @@ func (c *nvmeCollector) Update(ch chan<- prometheus.Metric) error {
 
 			// Namespace logical block size in bytes
 			ch <- prometheus.MustNewConstMetric(
-				c.namespaceLogicalBlockSizeBytes,
+				nvmeNamespaceLogicalBlockSizeBytes,
 				prometheus.GaugeValue,
 				float64(namespace.LogicalBlockSize),
 				device.Name,
diff --git a/collector/os_release.go b/collector/os_release.go
index 6acf9bed02..34c1557748 100644
--- a/collector/os_release.go
+++ b/collector/os_release.go
@@ -58,15 +58,12 @@ type osRelease struct {
 }
 
 type osReleaseCollector struct {
-	infoDesc           *prometheus.Desc
 	logger             *slog.Logger
 	os                 *osRelease
 	osMutex            sync.RWMutex
 	osReleaseFilenames []string // all os-release file names to check
 	version            float64
-	versionDesc        *prometheus.Desc
 	supportEnd         time.Time
-	supportEndDesc     *prometheus.Desc
 }
 
 type Plist struct {
@@ -82,28 +79,31 @@ func init() {
 	registerCollector("os", defaultEnabled, NewOSCollector)
 }
 
+var (
+	osInfoDesc = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "os", "info"),
+		"A metric with a constant '1' value labeled by build_id, id, id_like, image_id, image_version, "+
+			"name, pretty_name, variant, variant_id, version, version_codename, version_id.",
+		[]string{"build_id", "id", "id_like", "image_id", "image_version", "name", "pretty_name",
+			"variant", "variant_id", "version", "version_codename", "version_id"}, nil,
+	)
+	osVersionDesc = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "os", "version"),
+		"Metric containing the major.minor part of the OS version.",
+		[]string{"id", "id_like", "name"}, nil,
+	)
+	osSupportEndDesc = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "os", "support_end_timestamp_seconds"),
+		"Metric containing the end-of-life date timestamp of the OS.",
+		nil, nil,
+	)
+)
+
 // NewOSCollector returns a new Collector exposing os-release information.
 func NewOSCollector(logger *slog.Logger) (Collector, error) {
 	return &osReleaseCollector{
-		logger: logger,
-		infoDesc: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "os", "info"),
-			"A metric with a constant '1' value labeled by build_id, id, id_like, image_id, image_version, "+
-				"name, pretty_name, variant, variant_id, version, version_codename, version_id.",
-			[]string{"build_id", "id", "id_like", "image_id", "image_version", "name", "pretty_name",
-				"variant", "variant_id", "version", "version_codename", "version_id"}, nil,
-		),
+		logger:             logger,
 		osReleaseFilenames: []string{etcOSRelease, usrLibOSRelease, systemVersionPlist},
-		versionDesc: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "os", "version"),
-			"Metric containing the major.minor part of the OS version.",
-			[]string{"id", "id_like", "name"}, nil,
-		),
-		supportEndDesc: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "os", "support_end_timestamp_seconds"),
-			"Metric containing the end-of-life date timestamp of the OS.",
-			nil, nil,
-		),
 	}, nil
 }
 
@@ -187,16 +187,16 @@ func (c *osReleaseCollector) Update(ch chan<- prometheus.Metric) error {
 		return err
 	}
 
-	ch <- prometheus.MustNewConstMetric(c.infoDesc, prometheus.GaugeValue, 1.0,
+	ch <- prometheus.MustNewConstMetric(osInfoDesc, prometheus.GaugeValue, 1.0,
 		c.os.BuildID, c.os.ID, c.os.IDLike, c.os.ImageID, c.os.ImageVersion, c.os.Name, c.os.PrettyName,
 		c.os.Variant, c.os.VariantID, c.os.Version, c.os.VersionCodename, c.os.VersionID)
 	if c.version > 0 {
-		ch <- prometheus.MustNewConstMetric(c.versionDesc, prometheus.GaugeValue, c.version,
+		ch <- prometheus.MustNewConstMetric(osVersionDesc, prometheus.GaugeValue, c.version,
 			c.os.ID, c.os.IDLike, c.os.Name)
 	}
 
 	if c.os.SupportEnd != "" {
-		ch <- prometheus.MustNewConstMetric(c.supportEndDesc, prometheus.GaugeValue, float64(c.supportEnd.Unix()))
+		ch <- prometheus.MustNewConstMetric(osSupportEndDesc, prometheus.GaugeValue, float64(c.supportEnd.Unix()))
 	}
 
 	return nil
diff --git a/collector/stat_linux.go b/collector/stat_linux.go
index 199390620e..e7efeef0b8 100644
--- a/collector/stat_linux.go
+++ b/collector/stat_linux.go
@@ -25,15 +25,8 @@ import (
 )
 
 type statCollector struct {
-	fs           procfs.FS
-	intr         *prometheus.Desc
-	ctxt         *prometheus.Desc
-	forks        *prometheus.Desc
-	btime        *prometheus.Desc
-	procsRunning *prometheus.Desc
-	procsBlocked *prometheus.Desc
-	softIRQ      *prometheus.Desc
-	logger       *slog.Logger
+	fs     procfs.FS
+	logger *slog.Logger
 }
 
 var statSoftirqFlag = kingpin.Flag("collector.stat.softirq", "Export softirq calls per vector").Default("false").Bool()
@@ -42,6 +35,44 @@ func init() {
 	registerCollector("stat", defaultEnabled, NewStatCollector)
 }
 
+var (
+	statIntr = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "intr_total"),
+		"Total number of interrupts serviced.",
+		nil, nil,
+	)
+	statCtxt = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "context_switches_total"),
+		"Total number of context switches.",
+		nil, nil,
+	)
+	statForks = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "forks_total"),
+		"Total number of forks.",
+		nil, nil,
+	)
+	statBtime = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "boot_time_seconds"),
+		"Node boot time, in unixtime.",
+		nil, nil,
+	)
+	statProcsRunning = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "procs_running"),
+		"Number of processes in runnable state.",
+		nil, nil,
+	)
+	statProcsBlocked = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "procs_blocked"),
+		"Number of processes blocked waiting for I/O to complete.",
+		nil, nil,
+	)
+	statSoftIRQ = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, "", "softirqs_total"),
+		"Number of softirq calls.",
+		[]string{"vector"}, nil,
+	)
+)
+
 // NewStatCollector returns a new Collector exposing kernel/system statistics.
 func NewStatCollector(logger *slog.Logger) (Collector, error) {
 	fs, err := procfs.NewFS(*procPath)
@@ -49,42 +80,7 @@ func NewStatCollector(logger *slog.Logger) (Collector, error) {
 		return nil, fmt.Errorf("failed to open procfs: %w", err)
 	}
 	return &statCollector{
-		fs: fs,
-		intr: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "intr_total"),
-			"Total number of interrupts serviced.",
-			nil, nil,
-		),
-		ctxt: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "context_switches_total"),
-			"Total number of context switches.",
-			nil, nil,
-		),
-		forks: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "forks_total"),
-			"Total number of forks.",
-			nil, nil,
-		),
-		btime: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "boot_time_seconds"),
-			"Node boot time, in unixtime.",
-			nil, nil,
-		),
-		procsRunning: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "procs_running"),
-			"Number of processes in runnable state.",
-			nil, nil,
-		),
-		procsBlocked: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "procs_blocked"),
-			"Number of processes blocked waiting for I/O to complete.",
-			nil, nil,
-		),
-		softIRQ: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, "", "softirqs_total"),
-			"Number of softirq calls.",
-			[]string{"vector"}, nil,
-		),
+		fs:     fs,
 		logger: logger,
 	}, nil
 }
@@ -96,14 +92,14 @@ func (c *statCollector) Update(ch chan<- prometheus.Metric) error {
 		return err
 	}
 
-	ch <- prometheus.MustNewConstMetric(c.intr, prometheus.CounterValue, float64(stats.IRQTotal))
-	ch <- prometheus.MustNewConstMetric(c.ctxt, prometheus.CounterValue, float64(stats.ContextSwitches))
-	ch <- prometheus.MustNewConstMetric(c.forks, prometheus.CounterValue, float64(stats.ProcessCreated))
+	ch <- prometheus.MustNewConstMetric(statIntr, prometheus.CounterValue, float64(stats.IRQTotal))
+	ch <- prometheus.MustNewConstMetric(statCtxt, prometheus.CounterValue, float64(stats.ContextSwitches))
+	ch <- prometheus.MustNewConstMetric(statForks, prometheus.CounterValue, float64(stats.ProcessCreated))
 
-	ch <- prometheus.MustNewConstMetric(c.btime, prometheus.GaugeValue, float64(stats.BootTime))
+	ch <- prometheus.MustNewConstMetric(statBtime, prometheus.GaugeValue, float64(stats.BootTime))
 
-	ch <- prometheus.MustNewConstMetric(c.procsRunning, prometheus.GaugeValue, float64(stats.ProcessesRunning))
-	ch <- prometheus.MustNewConstMetric(c.procsBlocked, prometheus.GaugeValue, float64(stats.ProcessesBlocked))
+	ch <- prometheus.MustNewConstMetric(statProcsRunning, prometheus.GaugeValue, float64(stats.ProcessesRunning))
+	ch <- prometheus.MustNewConstMetric(statProcsBlocked, prometheus.GaugeValue, float64(stats.ProcessesBlocked))
 
 	if *statSoftirqFlag {
 		si := stats.SoftIRQ
@@ -123,7 +119,7 @@ func (c *statCollector) Update(ch chan<- prometheus.Metric) error {
 			{name: "hrtimer", value: si.Hrtimer},
 			{name: "rcu", value: si.Rcu},
 		} {
-			ch <- prometheus.MustNewConstMetric(c.softIRQ, prometheus.CounterValue, float64(vec.value), vec.name)
+			ch <- prometheus.MustNewConstMetric(statSoftIRQ, prometheus.CounterValue, float64(vec.value), vec.name)
 		}
 	}
 
diff --git a/collector/wifi_linux.go b/collector/wifi_linux.go
index 0d2a6b088b..8f482c76ce 100644
--- a/collector/wifi_linux.go
+++ b/collector/wifi_linux.go
@@ -29,22 +29,6 @@ import (
 )
 
 type wifiCollector struct {
-	interfaceFrequencyHertz *prometheus.Desc
-	stationInfo             *prometheus.Desc
-
-	stationConnectedSecondsTotal   *prometheus.Desc
-	stationInactiveSeconds         *prometheus.Desc
-	stationReceiveBitsPerSecond    *prometheus.Desc
-	stationTransmitBitsPerSecond   *prometheus.Desc
-	stationReceiveBytesTotal       *prometheus.Desc
-	stationTransmitBytesTotal      *prometheus.Desc
-	stationSignalDBM               *prometheus.Desc
-	stationTransmitRetriesTotal    *prometheus.Desc
-	stationTransmitFailedTotal     *prometheus.Desc
-	stationBeaconLossTotal         *prometheus.Desc
-	stationTransmittedPacketsTotal *prometheus.Desc
-	stationReceivedPacketsTotal    *prometheus.Desc
-
 	logger *slog.Logger
 }
 
@@ -66,114 +50,102 @@ type wifiStater interface {
 	StationInfo(ifi *wifi.Interface) ([]*wifi.StationInfo, error)
 }
 
-// NewWifiCollector returns a new Collector exposing Wifi statistics.
-func NewWifiCollector(logger *slog.Logger) (Collector, error) {
-	const (
-		subsystem = "wifi"
-	)
+const (
+	wifiSubsystem = "wifi"
+)
+
+var (
+	wifiLabels = []string{"device", "mac_address"}
 
-	var (
-		labels = []string{"device", "mac_address"}
+	wifiInterfaceFrequencyHertz = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "interface_frequency_hertz"),
+		"The current frequency a WiFi interface is operating at, in hertz.",
+		[]string{"device"},
+		nil,
+	)
+	wifiStationInfo = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_info"),
+		"Labeled WiFi interface station information as provided by the operating system.",
+		[]string{"device", "bssid", "ssid", "mode"},
+		nil,
+	)
+	wifiStationConnectedSecondsTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_connected_seconds_total"),
+		"The total number of seconds a station has been connected to an access point.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationInactiveSeconds = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_inactive_seconds"),
+		"The number of seconds since any wireless activity has occurred on a station.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationReceiveBitsPerSecond = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_receive_bits_per_second"),
+		"The current WiFi receive bitrate of a station, in bits per second.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationTransmitBitsPerSecond = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_transmit_bits_per_second"),
+		"The current WiFi transmit bitrate of a station, in bits per second.",
+		wifiLabels,
+		nil,
 	)
+	wifiStationReceiveBytesTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_receive_bytes_total"),
+		"The total number of bytes received by a WiFi station.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationTransmitBytesTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_transmit_bytes_total"),
+		"The total number of bytes transmitted by a WiFi station.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationSignalDBM = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_signal_dbm"),
+		"The current WiFi signal strength, in decibel-milliwatts (dBm).",
+		wifiLabels,
+		nil,
+	)
+	wifiStationTransmitRetriesTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_transmit_retries_total"),
+		"The total number of times a station has had to retry while sending a packet.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationTransmitFailedTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_transmit_failed_total"),
+		"The total number of times a station has failed to send a packet.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationBeaconLossTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_beacon_loss_total"),
+		"The total number of times a station has detected a beacon loss.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationTransmittedPacketsTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_transmitted_packets_total"),
+		"The total number of packets transmitted by a station.",
+		wifiLabels,
+		nil,
+	)
+	wifiStationReceivedPacketsTotal = prometheus.NewDesc(
+		prometheus.BuildFQName(namespace, wifiSubsystem, "station_received_packets_total"),
+		"The total number of packets received by a station.",
+		wifiLabels,
+		nil,
+	)
+)
 
+// NewWifiCollector returns a new Collector exposing Wifi statistics.
+func NewWifiCollector(logger *slog.Logger) (Collector, error) {
 	return &wifiCollector{
-		interfaceFrequencyHertz: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "interface_frequency_hertz"),
-			"The current frequency a WiFi interface is operating at, in hertz.",
-			[]string{"device"},
-			nil,
-		),
-
-		stationInfo: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_info"),
-			"Labeled WiFi interface station information as provided by the operating system.",
-			[]string{"device", "bssid", "ssid", "mode"},
-			nil,
-		),
-
-		stationConnectedSecondsTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_connected_seconds_total"),
-			"The total number of seconds a station has been connected to an access point.",
-			labels,
-			nil,
-		),
-
-		stationInactiveSeconds: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_inactive_seconds"),
-			"The number of seconds since any wireless activity has occurred on a station.",
-			labels,
-			nil,
-		),
-
-		stationReceiveBitsPerSecond: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_receive_bits_per_second"),
-			"The current WiFi receive bitrate of a station, in bits per second.",
-			labels,
-			nil,
-		),
-
-		stationTransmitBitsPerSecond: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_transmit_bits_per_second"),
-			"The current WiFi transmit bitrate of a station, in bits per second.",
-			labels,
-			nil,
-		),
-
-		stationReceiveBytesTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_receive_bytes_total"),
-			"The total number of bytes received by a WiFi station.",
-			labels,
-			nil,
-		),
-
-		stationTransmitBytesTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_transmit_bytes_total"),
-			"The total number of bytes transmitted by a WiFi station.",
-			labels,
-			nil,
-		),
-
-		stationSignalDBM: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_signal_dbm"),
-			"The current WiFi signal strength, in decibel-milliwatts (dBm).",
-			labels,
-			nil,
-		),
-
-		stationTransmitRetriesTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_transmit_retries_total"),
-			"The total number of times a station has had to retry while sending a packet.",
-			labels,
-			nil,
-		),
-
-		stationTransmitFailedTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_transmit_failed_total"),
-			"The total number of times a station has failed to send a packet.",
-			labels,
-			nil,
-		),
-
-		stationBeaconLossTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_beacon_loss_total"),
-			"The total number of times a station has detected a beacon loss.",
-			labels,
-			nil,
-		),
-
-		stationTransmittedPacketsTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_transmitted_packets_total"),
-			"The total number of packets transmitted by a station.",
-			labels,
-			nil,
-		),
-
-		stationReceivedPacketsTotal: prometheus.NewDesc(
-			prometheus.BuildFQName(namespace, subsystem, "station_received_packets_total"),
-			"The total number of packets received by a station.",
-			labels,
-			nil,
-		),
 		logger: logger,
 	}, nil
 }
@@ -209,7 +181,7 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
 		c.logger.Debug("probing wifi device with type", "wifi", ifi.Name, "type", ifi.Type)
 
 		ch <- prometheus.MustNewConstMetric(
-			c.interfaceFrequencyHertz,
+			wifiInterfaceFrequencyHertz,
 			prometheus.GaugeValue,
 			mHzToHz(ifi.Frequency),
 			ifi.Name,
@@ -250,7 +222,7 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
 func (c *wifiCollector) updateBSSStats(ch chan<- prometheus.Metric, device string, bss *wifi.BSS) {
 	// Synthetic metric which provides wifi station info, such as SSID, BSSID, etc.
 	ch <- prometheus.MustNewConstMetric(
-		c.stationInfo,
+		wifiStationInfo,
 		prometheus.GaugeValue,
 		1,
 		device,
@@ -262,7 +234,7 @@ func (c *wifiCollector) updateBSSStats(ch chan<- prometheus.Metric, device strin
 
 func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device string, info *wifi.StationInfo) {
 	ch <- prometheus.MustNewConstMetric(
-		c.stationConnectedSecondsTotal,
+		wifiStationConnectedSecondsTotal,
 		prometheus.CounterValue,
 		info.Connected.Seconds(),
 		device,
@@ -270,7 +242,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationInactiveSeconds,
+		wifiStationInactiveSeconds,
 		prometheus.GaugeValue,
 		info.Inactive.Seconds(),
 		device,
@@ -278,7 +250,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationReceiveBitsPerSecond,
+		wifiStationReceiveBitsPerSecond,
 		prometheus.GaugeValue,
 		float64(info.ReceiveBitrate),
 		device,
@@ -286,7 +258,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationTransmitBitsPerSecond,
+		wifiStationTransmitBitsPerSecond,
 		prometheus.GaugeValue,
 		float64(info.TransmitBitrate),
 		device,
@@ -294,7 +266,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationReceiveBytesTotal,
+		wifiStationReceiveBytesTotal,
 		prometheus.CounterValue,
 		float64(info.ReceivedBytes),
 		device,
@@ -302,7 +274,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationTransmitBytesTotal,
+		wifiStationTransmitBytesTotal,
 		prometheus.CounterValue,
 		float64(info.TransmittedBytes),
 		device,
@@ -310,7 +282,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationSignalDBM,
+		wifiStationSignalDBM,
 		prometheus.GaugeValue,
 		float64(info.Signal),
 		device,
@@ -318,7 +290,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationTransmitRetriesTotal,
+		wifiStationTransmitRetriesTotal,
 		prometheus.CounterValue,
 		float64(info.TransmitRetries),
 		device,
@@ -326,7 +298,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationTransmitFailedTotal,
+		wifiStationTransmitFailedTotal,
 		prometheus.CounterValue,
 		float64(info.TransmitFailed),
 		device,
@@ -334,7 +306,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationBeaconLossTotal,
+		wifiStationBeaconLossTotal,
 		prometheus.CounterValue,
 		float64(info.BeaconLoss),
 		device,
@@ -342,7 +314,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationTransmittedPacketsTotal,
+		wifiStationTransmittedPacketsTotal,
 		prometheus.CounterValue,
 		float64(info.TransmittedPackets),
 		device,
@@ -350,7 +322,7 @@ func (c *wifiCollector) updateStationStats(ch chan<- prometheus.Metric, device s
 	)
 
 	ch <- prometheus.MustNewConstMetric(
-		c.stationReceivedPacketsTotal,
+		wifiStationReceivedPacketsTotal,
 		prometheus.CounterValue,
 		float64(info.ReceivedPackets),
 		device,