| package daemon // import "github.com/docker/docker/daemon" |
| |
| import ( |
| "sync" |
| |
| "github.com/docker/docker/errdefs" |
| "github.com/docker/docker/pkg/plugingetter" |
| "github.com/docker/docker/pkg/plugins" |
| 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 |
| hostInfoFunctions 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) |
| } |
| hostInfoFunctions = ns.NewLabeledTimer("host_info_functions", "The number of seconds it takes to call functions gathering info about the host", "function") |
| |
| 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", |
| "os_version", |
| "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 (daemon *Daemon) cleanupMetricsPlugins() { |
| ls := daemon.PluginStore.GetAllManagedPluginsByCap(metricsPluginType) |
| var wg sync.WaitGroup |
| wg.Add(len(ls)) |
| |
| for _, plugin := range ls { |
| p := plugin |
| go func() { |
| defer wg.Done() |
| |
| adapter, err := makePluginAdapter(p) |
| if err != nil { |
| logrus.WithError(err).WithField("plugin", p.Name()).Error("Error creating metrics plugin adapter") |
| return |
| } |
| if err := adapter.StopMetrics(); err != nil { |
| logrus.WithError(err).WithField("plugin", p.Name()).Error("Error stopping plugin metrics collection") |
| } |
| }() |
| } |
| wg.Wait() |
| |
| if daemon.metricsPluginListener != nil { |
| daemon.metricsPluginListener.Close() |
| } |
| } |
| |
| type metricsPlugin interface { |
| StartMetrics() error |
| StopMetrics() error |
| } |
| |
| func makePluginAdapter(p plugingetter.CompatPlugin) (metricsPlugin, error) { |
| if pc, ok := p.(plugingetter.PluginWithV1Client); ok { |
| return &metricsPluginAdapter{pc.Client(), p.Name()}, nil |
| } |
| |
| pa, ok := p.(plugingetter.PluginAddr) |
| if !ok { |
| return nil, errdefs.System(errors.Errorf("got unknown plugin type %T", p)) |
| } |
| |
| if pa.Protocol() != plugins.ProtocolSchemeHTTPV1 { |
| return nil, errors.Errorf("plugin protocol not supported: %s", pa.Protocol()) |
| } |
| |
| addr := pa.Addr() |
| client, err := plugins.NewClientWithTimeout(addr.Network()+"://"+addr.String(), nil, pa.Timeout()) |
| if err != nil { |
| return nil, errors.Wrap(err, "error creating metrics plugin client") |
| } |
| return &metricsPluginAdapter{client, p.Name()}, nil |
| } |
| |
| type metricsPluginAdapter struct { |
| c *plugins.Client |
| name string |
| } |
| |
| func (a *metricsPluginAdapter) StartMetrics() error { |
| type metricsPluginResponse struct { |
| Err string |
| } |
| var res metricsPluginResponse |
| if err := a.c.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 (a *metricsPluginAdapter) StopMetrics() error { |
| if err := a.c.Call(metricsPluginType+".StopMetrics", nil, nil); err != nil { |
| return errors.Wrap(err, "error stopping metrics collector") |
| } |
| return nil |
| } |