chore: Refactor Config Collector API (#1558)

pkg/collector/printer/printer.go

@@ -29,37 +29,41 @@ var printerStatusMap = map[uint16]string{
 }
 
 type Config struct {
-	PrinterInclude string `yaml:"printer_include"`
-	PrinterExclude string `yaml:"printer_exclude"`
+	PrinterInclude *regexp.Regexp `yaml:"printer_include"`
+	PrinterExclude *regexp.Regexp `yaml:"printer_exclude"`
 }
 
 var ConfigDefaults = Config{
-	PrinterInclude: ".+",
-	PrinterExclude: "",
+	PrinterInclude: types.RegExpAny,
+	PrinterExclude: types.RegExpEmpty,
 }
 
 type Collector struct {
+	config Config
 	logger log.Logger
 
-	printerInclude *string
-	printerExclude *string
-
 	printerStatus    *prometheus.Desc
 	printerJobStatus *prometheus.Desc
 	printerJobCount  *prometheus.Desc
-
-	printerIncludePattern *regexp.Regexp
-	printerExcludePattern *regexp.Regexp
 }
 
 func New(logger log.Logger, config *Config) *Collector {
 	if config == nil {
 		config = &ConfigDefaults
 	}
-	c := &Collector{
-		printerInclude: &config.PrinterInclude,
-		printerExclude: &config.PrinterExclude,
+
+	if config.PrinterExclude == nil {
+		config.PrinterExclude = ConfigDefaults.PrinterExclude
 	}
+
+	if config.PrinterInclude == nil {
+		config.PrinterInclude = ConfigDefaults.PrinterInclude
+	}
+
+	c := &Collector{
+		config: *config,
+	}
+
 	c.SetLogger(logger)
 
 	return c
@@ -67,17 +71,37 @@ func New(logger log.Logger, config *Config) *Collector {
 
 func NewWithFlags(app *kingpin.Application) *Collector {
 	c := &Collector{
-		printerInclude: app.Flag(
-			"collector.printer.include",
-			"Regular expression to match printers to collect metrics for",
-		).Default(ConfigDefaults.PrinterInclude).String(),
-
-		printerExclude: app.Flag(
-			"collector.printer.exclude",
-			"Regular expression to match printers to exclude",
-		).Default(ConfigDefaults.PrinterExclude).String(),
+		config: ConfigDefaults,
 	}
 
+	var printerInclude, printerExclude string
+
+	app.Flag(
+		"collector.printer.include",
+		"Regular expression to match printers to collect metrics for",
+	).Default(c.config.PrinterInclude.String()).StringVar(&printerInclude)
+
+	app.Flag(
+		"collector.printer.exclude",
+		"Regular expression to match printers to exclude",
+	).Default(c.config.PrinterExclude.String()).StringVar(&printerExclude)
+
+	app.Action(func(*kingpin.ParseContext) error {
+		var err error
+
+		c.config.PrinterInclude, err = regexp.Compile(fmt.Sprintf("^(?:%s)$", printerInclude))
+		if err != nil {
+			return fmt.Errorf("collector.printer.include: %w", err)
+		}
+
+		c.config.PrinterExclude, err = regexp.Compile(fmt.Sprintf("^(?:%s)$", printerExclude))
+		if err != nil {
+			return fmt.Errorf("collector.printer.exclude: %w", err)
+		}
+
+		return nil
+	})
+
 	return c
 }
 
@@ -109,27 +133,21 @@ func (c *Collector) Build() error {
 		nil,
 	)
 
-	var err error
-	c.printerIncludePattern, err = regexp.Compile(fmt.Sprintf("^(?:%s)$", *c.printerInclude))
-	if err != nil {
-		return err
-	}
-	c.printerExcludePattern, err = regexp.Compile(fmt.Sprintf("^(?:%s)$", *c.printerExclude))
-	return err
+	return nil
 }
 
 func (c *Collector) GetName() string { return Name }
 
 func (c *Collector) GetPerfCounter() ([]string, error) { return []string{"Printer"}, nil }
 
-type win32_Printer struct {
+type wmiPrinter struct {
 	Name                   string
 	Default                bool
 	PrinterStatus          uint16
 	JobCountSinceLastReset uint32
 }
 
-type win32_PrintJob struct {
+type wmiPrintJob struct {
 	Name   string
 	Status string
 }
@@ -139,23 +157,26 @@ func (c *Collector) Collect(_ *types.ScrapeContext, ch chan<- prometheus.Metric)
 		_ = level.Error(c.logger).Log("msg", "failed to collect printer status metrics", "err", err)
 		return err
 	}
+
 	if err := c.collectPrinterJobStatus(ch); err != nil {
 		_ = level.Error(c.logger).Log("msg", "failed to collect printer job status metrics", "err", err)
 		return err
 	}
+
 	return nil
 }
 
 func (c *Collector) collectPrinterStatus(ch chan<- prometheus.Metric) error {
-	var printers []win32_Printer
-	q := wmi.QueryAll(&printers, c.logger)
+	var printers []wmiPrinter
+
+	q := wmi.QueryAllForClass(&printers, "win32_Printer", c.logger)
 	if err := wmi.Query(q, &printers); err != nil {
 		return err
 	}
 
 	for _, printer := range printers {
-		if c.printerExcludePattern.MatchString(printer.Name) ||
-			!c.printerIncludePattern.MatchString(printer.Name) {
+		if c.config.PrinterExclude.MatchString(printer.Name) ||
+			!c.config.PrinterInclude.MatchString(printer.Name) {
 			continue
 		}
 
@@ -186,8 +207,9 @@ func (c *Collector) collectPrinterStatus(ch chan<- prometheus.Metric) error {
 }
 
 func (c *Collector) collectPrinterJobStatus(ch chan<- prometheus.Metric) error {
-	var printJobs []win32_PrintJob
-	q := wmi.QueryAll(&printJobs, c.logger)
+	var printJobs []wmiPrintJob
+
+	q := wmi.QueryAllForClass(&printJobs, "win32_PrintJob", c.logger)
 	if err := wmi.Query(q, &printJobs); err != nil {
 		return err
 	}
@@ -202,6 +224,7 @@ func (c *Collector) collectPrinterJobStatus(ch chan<- prometheus.Metric) error {
 			group.status,
 		)
 	}
+
 	return nil
 }
 
@@ -210,19 +233,22 @@ type PrintJobStatusGroup struct {
 	status      string
 }
 
-func (c *Collector) groupPrintJobs(printJobs []win32_PrintJob) map[PrintJobStatusGroup]int {
+func (c *Collector) groupPrintJobs(printJobs []wmiPrintJob) map[PrintJobStatusGroup]int {
 	groupedPrintJobs := make(map[PrintJobStatusGroup]int)
+
 	for _, printJob := range printJobs {
 		printerName := strings.Split(printJob.Name, ",")[0]
 
-		if c.printerExcludePattern.MatchString(printerName) ||
-			!c.printerIncludePattern.MatchString(printerName) {
+		if c.config.PrinterExclude.MatchString(printerName) ||
+			!c.config.PrinterInclude.MatchString(printerName) {
 			continue
 		}
+
 		groupedPrintJobs[PrintJobStatusGroup{
 			printerName: printerName,
 			status:      printJob.Status,
 		}]++
 	}
+
 	return groupedPrintJobs
 }