1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
package metrics
// todo: declare metric at runtime
import (
"context"
"fmt"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
"github.com/sirupsen/logrus"
"github.com/spiral/roadrunner/service/rpc"
"net/http"
"sync"
"time"
)
const (
// ID declares public service name.
ID = "metrics"
// maxHeaderSize declares max header size for prometheus server
maxHeaderSize = 1024 * 1024 * 100 // 104MB
)
// Service to manage application metrics using Prometheus.
type Service struct {
cfg *Config
log *logrus.Logger
mu sync.Mutex
http *http.Server
collectors sync.Map
registry *prometheus.Registry
}
// Init service.
func (s *Service) Init(cfg *Config, r *rpc.Service, log *logrus.Logger) (bool, error) {
s.cfg = cfg
s.log = log
s.registry = prometheus.NewRegistry()
s.registry.MustRegister(prometheus.NewProcessCollector(prometheus.ProcessCollectorOpts{}))
s.registry.MustRegister(prometheus.NewGoCollector())
if r != nil {
if err := r.Register(ID, &rpcServer{s}); err != nil {
return false, err
}
}
return true, nil
}
// Enabled indicates that server is able to collect metrics.
func (s *Service) Enabled() bool {
return s.cfg != nil
}
// Register new prometheus collector.
func (s *Service) Register(c prometheus.Collector) error {
return s.registry.Register(c)
}
// MustRegister registers new collector or fails with panic.
func (s *Service) MustRegister(c prometheus.Collector) {
s.registry.MustRegister(c)
}
// Serve prometheus metrics service.
func (s *Service) Serve() error {
// register application specific metrics
collectors, err := s.cfg.getCollectors()
if err != nil {
return err
}
for name, collector := range collectors {
if err := s.registry.Register(collector); err != nil {
return err
}
s.collectors.Store(name, collector)
}
s.mu.Lock()
s.http = &http.Server{
Addr: s.cfg.Address,
Handler: promhttp.HandlerFor(s.registry, promhttp.HandlerOpts{}, ),
IdleTimeout: time.Hour * 24,
ReadTimeout: time.Minute * 60,
MaxHeaderBytes: maxHeaderSize,
ReadHeaderTimeout: time.Minute * 60,
WriteTimeout: time.Minute * 60,
}
s.mu.Unlock()
err = s.http.ListenAndServe()
if err != nil && err != http.ErrServerClosed {
return err
}
return nil
}
// Stop prometheus metrics service.
func (s *Service) Stop() {
s.mu.Lock()
defer s.mu.Unlock()
if s.http != nil {
// gracefully stop server
go func() {
err := s.http.Shutdown(context.Background())
if err != nil {
// Function should be Stop() error
s.log.Error(fmt.Errorf("error shutting down the metrics server: error %v", err))
}
}()
}
}
// Collector returns application specific collector by name or nil if collector not found.
func (s *Service) Collector(name string) prometheus.Collector {
collector, ok := s.collectors.Load(name)
if !ok {
return nil
}
return collector.(prometheus.Collector)
}
|
