mirror of
https://github.com/genuinetools/reg.git
synced 2024-08-21 14:20:23 -04:00
150 lines
4.2 KiB
Go
150 lines
4.2 KiB
Go
package daemon // import "github.com/docker/docker/daemon"
|
|
|
|
import (
|
|
"sync"
|
|
|
|
"github.com/docker/docker/pkg/plugingetter"
|
|
metrics "github.com/docker/go-metrics"
|
|
"github.com/pkg/errors"
|
|
"github.com/prometheus/client_golang/prometheus"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
const metricsPluginType = "MetricsCollector"
|
|
|
|
var (
|
|
containerActions metrics.LabeledTimer
|
|
networkActions metrics.LabeledTimer
|
|
engineInfo metrics.LabeledGauge
|
|
engineCpus metrics.Gauge
|
|
engineMemory metrics.Gauge
|
|
healthChecksCounter metrics.Counter
|
|
healthChecksFailedCounter metrics.Counter
|
|
|
|
stateCtr *stateCounter
|
|
)
|
|
|
|
func init() {
|
|
ns := metrics.NewNamespace("engine", "daemon", nil)
|
|
containerActions = ns.NewLabeledTimer("container_actions", "The number of seconds it takes to process each container action", "action")
|
|
for _, a := range []string{
|
|
"start",
|
|
"changes",
|
|
"commit",
|
|
"create",
|
|
"delete",
|
|
} {
|
|
containerActions.WithValues(a).Update(0)
|
|
}
|
|
|
|
networkActions = ns.NewLabeledTimer("network_actions", "The number of seconds it takes to process each network action", "action")
|
|
engineInfo = ns.NewLabeledGauge("engine", "The information related to the engine and the OS it is running on", metrics.Unit("info"),
|
|
"version",
|
|
"commit",
|
|
"architecture",
|
|
"graphdriver",
|
|
"kernel", "os",
|
|
"os_type",
|
|
"daemon_id", // ID is a randomly generated unique identifier (e.g. UUID4)
|
|
)
|
|
engineCpus = ns.NewGauge("engine_cpus", "The number of cpus that the host system of the engine has", metrics.Unit("cpus"))
|
|
engineMemory = ns.NewGauge("engine_memory", "The number of bytes of memory that the host system of the engine has", metrics.Bytes)
|
|
healthChecksCounter = ns.NewCounter("health_checks", "The total number of health checks")
|
|
healthChecksFailedCounter = ns.NewCounter("health_checks_failed", "The total number of failed health checks")
|
|
|
|
stateCtr = newStateCounter(ns.NewDesc("container_states", "The count of containers in various states", metrics.Unit("containers"), "state"))
|
|
ns.Add(stateCtr)
|
|
|
|
metrics.Register(ns)
|
|
}
|
|
|
|
type stateCounter struct {
|
|
mu sync.Mutex
|
|
states map[string]string
|
|
desc *prometheus.Desc
|
|
}
|
|
|
|
func newStateCounter(desc *prometheus.Desc) *stateCounter {
|
|
return &stateCounter{
|
|
states: make(map[string]string),
|
|
desc: desc,
|
|
}
|
|
}
|
|
|
|
func (ctr *stateCounter) get() (running int, paused int, stopped int) {
|
|
ctr.mu.Lock()
|
|
defer ctr.mu.Unlock()
|
|
|
|
states := map[string]int{
|
|
"running": 0,
|
|
"paused": 0,
|
|
"stopped": 0,
|
|
}
|
|
for _, state := range ctr.states {
|
|
states[state]++
|
|
}
|
|
return states["running"], states["paused"], states["stopped"]
|
|
}
|
|
|
|
func (ctr *stateCounter) set(id, label string) {
|
|
ctr.mu.Lock()
|
|
ctr.states[id] = label
|
|
ctr.mu.Unlock()
|
|
}
|
|
|
|
func (ctr *stateCounter) del(id string) {
|
|
ctr.mu.Lock()
|
|
delete(ctr.states, id)
|
|
ctr.mu.Unlock()
|
|
}
|
|
|
|
func (ctr *stateCounter) Describe(ch chan<- *prometheus.Desc) {
|
|
ch <- ctr.desc
|
|
}
|
|
|
|
func (ctr *stateCounter) Collect(ch chan<- prometheus.Metric) {
|
|
running, paused, stopped := ctr.get()
|
|
ch <- prometheus.MustNewConstMetric(ctr.desc, prometheus.GaugeValue, float64(running), "running")
|
|
ch <- prometheus.MustNewConstMetric(ctr.desc, prometheus.GaugeValue, float64(paused), "paused")
|
|
ch <- prometheus.MustNewConstMetric(ctr.desc, prometheus.GaugeValue, float64(stopped), "stopped")
|
|
}
|
|
|
|
func (d *Daemon) cleanupMetricsPlugins() {
|
|
ls := d.PluginStore.GetAllManagedPluginsByCap(metricsPluginType)
|
|
var wg sync.WaitGroup
|
|
wg.Add(len(ls))
|
|
|
|
for _, plugin := range ls {
|
|
p := plugin
|
|
go func() {
|
|
defer wg.Done()
|
|
pluginStopMetricsCollection(p)
|
|
}()
|
|
}
|
|
wg.Wait()
|
|
|
|
if d.metricsPluginListener != nil {
|
|
d.metricsPluginListener.Close()
|
|
}
|
|
}
|
|
|
|
func pluginStartMetricsCollection(p plugingetter.CompatPlugin) error {
|
|
type metricsPluginResponse struct {
|
|
Err string
|
|
}
|
|
var res metricsPluginResponse
|
|
if err := p.Client().Call(metricsPluginType+".StartMetrics", nil, &res); err != nil {
|
|
return errors.Wrap(err, "could not start metrics plugin")
|
|
}
|
|
if res.Err != "" {
|
|
return errors.New(res.Err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func pluginStopMetricsCollection(p plugingetter.CompatPlugin) {
|
|
if err := p.Client().Call(metricsPluginType+".StopMetrics", nil, nil); err != nil {
|
|
logrus.WithError(err).WithField("name", p.Name()).Error("error stopping metrics collector")
|
|
}
|
|
}
|