CAdvisor container monitor

Now cadvisor is useful as a container montor tool. Not only it can monitor many container level metrics, but also can expand some metrics which we need.

It`s a open source project URL: https://github.com/google/cadvisor.git

its master branch has a lot of defects. One of the problem is the daemon. url was wrote dead.In docker/container/clients.go, it was wrote to"unix://xxxxxxx",

In order to expand, it should be a dynamic parameter.

eg: func clients (clients string){

　　　******

　　}

run a docker container:

download the images:

go get githun.com/google/cadvisor /  git clone https://github.com/google/cadvisor.git /  download the zip package and unzip

docker command

sudo docker run \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:rw \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=: \
  --detach=true \
  --name=cadvisor \
  google/cadvisor:latest

the default port is 8080.

the cadvisor container is running on localhost:8080. The metrics infomation is on localhost:8080/metrics The graph show on localhost:8080/graph

Every metrics colector is achived in google/cadvisor/collector/.... We can overwrite the collector and describle interface to register new collector.But if we update this change in vendor, we can not promisor the tags version.(glide up -v or glide up install)

 // Returns a new CollectorManager that is thread-compatible.
 func NewCollectorManager() (CollectorManager, error) {
     return &GenericCollectorManager{
         Collectors:         []*collectorData{},
         NextCollectionTime: time.Now(),
     }, nil
 }

 func GetCollectorConfigs(labels map[string]string) map[string]string {
     configs := map[string]string{}
     for k, v := range labels {
         if strings.HasPrefix(k, metricLabelPrefix) {
             name := strings.TrimPrefix(k, metricLabelPrefix)
             configs[name] = v
         }
     }
     return configs
 }

 func (cm *GenericCollectorManager) RegisterCollector(collector Collector) error {
     cm.Collectors = append(cm.Collectors, &collectorData{
         collector:          collector,
         nextCollectionTime: time.Now(),
     })
     return nil
 }

 func (cm *GenericCollectorManager) GetSpec() ([]v1.MetricSpec, error) {
     metricSpec := []v1.MetricSpec{}
     for _, c := range cm.Collectors {
         specs := c.collector.GetSpec()
         metricSpec = append(metricSpec, specs...)
     }

     return metricSpec, nil
 }

 func (cm *GenericCollectorManager) Collect() (time.Time, map[string][]v1.MetricVal, error) {
     var errors []error

     // Collect from all collectors that are ready.
     var next time.Time
     metrics := map[string][]v1.MetricVal{}
     for _, c := range cm.Collectors {
         if c.nextCollectionTime.Before(time.Now()) {
             var err error3
             c.nextCollectionTime, metrics, err = c.collector.Collect(metrics)
             if err != nil {
                 errors = append(errors, err)
             }
         }

         // Keep track of the next collector that will be ready.
         if next.IsZero() || next.After(c.nextCollectionTime) {
             next = c.nextCollectionTime
         }
     }
     cm.NextCollectionTime = next
     return next, metrics, compileErrors(errors)
 }

We can build a new image in the localhost by achive the interface instead of use the default package by glide up -v.

for example:

we can set up a socket client with docker daemon. and get the inspect infomation.Docker inspect info has a container restart count.

we can expand this metrics by user follow step:

(1) register the collector

(2) new a collector client including some infomation (metric name , mode, help and so on)

(3) achive the collect and the descible interface.