pangolin_exporter

1
// Copyright 2022 The Prometheus Authors
2
// Licensed under the Apache License, Version 2.0 (the "License");
3
// you may not use this file except in compliance with the License.
4
// You may obtain a copy of the License at
5
//
6
// http://www.apache.org/licenses/LICENSE-2.0
7
//
8
// Unless required by applicable law or agreed to in writing, software
9
// distributed under the License is distributed on an "AS IS" BASIS,
10
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11
// See the License for the specific language governing permissions and
12
// limitations under the License.
13

14
package collector
15

16
import (
17
	"context"
18
	"sync"
19

20
	"github.com/go-kit/log"
21
	"github.com/go-kit/log/level"
22
	"github.com/prometheus-community/postgres_exporter/config"
23
	"github.com/prometheus/client_golang/prometheus"
24
)
25

26
type ProbeCollector struct {
27
	registry   *prometheus.Registry
28
	collectors map[string]Collector
29
	logger     log.Logger
30
	instance   *instance
31
}
32

33
func NewProbeCollector(logger log.Logger, excludeDatabases []string, registry *prometheus.Registry, dsn config.DSN) (*ProbeCollector, error) {
34
	collectors := make(map[string]Collector)
35
	initiatedCollectorsMtx.Lock()
36
	defer initiatedCollectorsMtx.Unlock()
37
	for key, enabled := range collectorState {
38
		// TODO: Handle filters
39
		// if !*enabled || (len(f) > 0 && !f[key]) {
40
		// 	continue
41
		// }
42
		if !*enabled {
43
			continue
44
		}
45
		if collector, ok := initiatedCollectors[key]; ok {
46
			collectors[key] = collector
47
		} else {
48
			collector, err := factories[key](
49
				collectorConfig{
50
					logger:           log.With(logger, "collector", key),
51
					excludeDatabases: excludeDatabases,
52
				})
53
			if err != nil {
54
				return nil, err
55
			}
56
			collectors[key] = collector
57
			initiatedCollectors[key] = collector
58
		}
59
	}
60

61
	instance, err := newInstance(dsn.GetConnectionString())
62
	if err != nil {
63
		return nil, err
64
	}
65

66
	return &ProbeCollector{
67
		registry:   registry,
68
		collectors: collectors,
69
		logger:     logger,
70
		instance:   instance,
71
	}, nil
72
}
73

74
func (pc *ProbeCollector) Describe(ch chan<- *prometheus.Desc) {
75
}
76

77
func (pc *ProbeCollector) Collect(ch chan<- prometheus.Metric) {
78
	// Set up the database connection for the collector.
79
	err := pc.instance.setup()
80
	if err != nil {
81
		level.Error(pc.logger).Log("msg", "Error opening connection to database", "err", err)
82
		return
83
	}
84
	defer pc.instance.Close()
85

86
	wg := sync.WaitGroup{}
87
	wg.Add(len(pc.collectors))
88
	for name, c := range pc.collectors {
89
		go func(name string, c Collector) {
90
			execute(context.TODO(), name, c, pc.instance, ch, pc.logger)
91
			wg.Done()
92
		}(name, c)
93
	}
94
	wg.Wait()
95
}
96

97
func (pc *ProbeCollector) Close() error {
98
	return pc.instance.Close()
99
}
100