cmd,collector: reduce connections during /metrics scrapes

Signed-off-by: Max Englander <[email protected]>

Author: maxenglander

cmd/postgres_exporter/main.go

@@ -133,17 +133,37 @@ func main() {
 		dsn = dsns[0]
 	}
 
-	pe, err := collector.NewPostgresCollector(
-		logger,
-		excludedDatabases,
-		dsn,
-		[]string{},
-		collector.WithTimeout(*scrapeTimeout),
-	)
-	if err != nil {
-		logger.Warn("Failed to create PostgresCollector", "err", err.Error())
-	} else {
-		prometheus.MustRegister(pe)
+	if dsn != "" {
+		// Get the server connection to share with collectors
+		server, err := exporter.servers.GetServer(dsn)
+		if err != nil {
+			logger.Warn("Failed to get server for collectors", "err", err.Error())
+		} else {
+			// Create instance with shared connection from server
+			instance, err := collector.NewInstance(dsn)
+			if err != nil {
+				logger.Warn("Failed to create instance", "err", err.Error())
+			} else {
+				err = instance.SetupWithConnection(server.db)
+				if err != nil {
+					logger.Warn("Failed to setup shared instance", "err", err.Error())
+				} else {
+					// Create collector with shared instance (instancePerCollect defaults to false)
+					pe, err := collector.NewPostgresCollector(
+						logger,
+						excludedDatabases,
+						instance,
+						[]string{},
+						collector.WithTimeout(*scrapeTimeout),
+					)
+					if err != nil {
+						logger.Warn("Failed to create PostgresCollector", "err", err.Error())
+					} else {
+						prometheus.MustRegister(pe)
+					}
+				}
+			}
+		}
 	}
 
 	http.Handle(*metricsPath, promhttp.Handler())

collector/collector.go

@@ -93,7 +93,8 @@ type PostgresCollector struct {
 	logger        *slog.Logger
 	scrapeTimeout time.Duration
 
-	instance *instance
+	instance           *instance
+	instancePerCollect bool
 }
 
 type Option func(*PostgresCollector) error
@@ -106,10 +107,19 @@ func WithTimeout(timeout time.Duration) Option {
 	}
 }
 
+// WithInstancePerCollect configures whether to create a new instance per Collect call.
+func WithInstancePerCollect() Option {
+	return func(p *PostgresCollector) error {
+		p.instancePerCollect = true
+		return nil
+	}
+}
+
 // NewPostgresCollector creates a new PostgresCollector.
-func NewPostgresCollector(logger *slog.Logger, excludeDatabases []string, dsn string, filters []string, options ...Option) (*PostgresCollector, error) {
+func NewPostgresCollector(logger *slog.Logger, excludeDatabases []string, instance *instance, filters []string, options ...Option) (*PostgresCollector, error) {
 	p := &PostgresCollector{
-		logger: logger,
+		logger:   logger,
+		instance: instance,
 	}
 	// Apply options to customize the collector
 	for _, o := range options {
@@ -154,16 +164,6 @@ func NewPostgresCollector(logger *slog.Logger, excludeDatabases []string, dsn st
 
 	p.Collectors = collectors
 
-	if dsn == "" {
-		return nil, errors.New("empty dsn")
-	}
-
-	instance, err := newInstance(dsn)
-	if err != nil {
-		return nil, err
-	}
-	p.instance = instance
-
 	return p, nil
 }
 
@@ -184,15 +184,21 @@ func (p PostgresCollector) Collect(ch chan<- prometheus.Metric) {
 		ctx = context.Background()
 	}
 
-	// copy the instance so that concurrent scrapes have independent instances
-	inst := p.instance.copy()
+	var inst *instance
 
-	// Set up the database connection for the collector.
-	err := inst.setup()
-	defer inst.Close()
-	if err != nil {
-		p.logger.Error("Error opening connection to database", "err", err)
-		return
+	if p.instancePerCollect {
+		// copy the instance so that concurrent scrapes have independent instances
+		inst = p.instance.copy()
+		// Set up the database connection for the collector.
+		err := inst.setup()
+		if err != nil {
+			p.logger.Error("Error opening connection to database", "err", err)
+			return
+		}
+		defer inst.Close()
+	} else {
+		// Use the shared instance directly
+		inst = p.instance
 	}
 
 	wg := sync.WaitGroup{}
@@ -206,10 +212,6 @@ func (p PostgresCollector) Collect(ch chan<- prometheus.Metric) {
 	wg.Wait()
 }
 
-func (p *PostgresCollector) Close() error {
-	return p.instance.Close()
-}
-
 func execute(ctx context.Context, name string, c Collector, instance *instance, ch chan<- prometheus.Metric, logger *slog.Logger) {
 	begin := time.Now()
 	err := c.Update(ctx, instance, ch)

collector/instance.go

@@ -27,7 +27,7 @@ type instance struct {
 	version semver.Version
 }
 
-func newInstance(dsn string) (*instance, error) {
+func NewInstance(dsn string) (*instance, error) {
 	i := &instance{
 		dsn: dsn,
 	}
@@ -68,6 +68,18 @@ func (i *instance) setup() error {
 	return nil
 }
 
+// SetupWithConnection sets up the instance with an existing database connection.
+func (i *instance) SetupWithConnection(db *sql.DB) error {
+	i.db = db
+
+	version, err := queryVersion(i.db)
+	if err != nil {
+		return fmt.Errorf("error querying postgresql version: %w", err)
+	}
+	i.version = version
+	return nil
+}
+
 func (i *instance) getDB() *sql.DB {
 	return i.db
 }

collector/probe.go

@@ -57,7 +57,7 @@ func NewProbeCollector(logger *slog.Logger, excludeDatabases []string, registry
 		}
 	}
 
-	instance, err := newInstance(dsn.GetConnectionString())
+	instance, err := NewInstance(dsn.GetConnectionString())
 	if err != nil {
 		return nil, err
 	}