Merge pull request #9149 from vmarmol/docker-errors

Kubelet: Add metric for tracking Docker error count

pkg/kubelet/dockertools/instrumented_docker.go

@@ -34,130 +34,158 @@ func NewInstrumentedDockerInterface(dockerClient DockerInterface) DockerInterfac
 	}
 }
 
+// Record the duration of the operation.
+func recordOperation(operation string, start time.Time) {
+	metrics.DockerOperationsLatency.WithLabelValues(operation).Observe(metrics.SinceInMicroseconds(start))
+}
+
+// Record error for metric if an error occured.
+func recordError(operation string, err error) {
+	if err != nil {
+		metrics.DockerErrors.WithLabelValues(operation).Inc()
+	}
+}
+
 func (in instrumentedDockerInterface) ListContainers(options docker.ListContainersOptions) ([]docker.APIContainers, error) {
-	start := time.Now()
+	const operation = "list_containers"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("list_containers").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.ListContainers(options)
-	return in.client.ListContainers(options)
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) InspectContainer(id string) (*docker.Container, error) {
-	start := time.Now()
+	const operation = "inspect_container"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("inspect_container").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.InspectContainer(id)
-	return in.client.InspectContainer(id)
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) CreateContainer(opts docker.CreateContainerOptions) (*docker.Container, error) {
-	start := time.Now()
+	const operation = "create_container"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("create_container").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.CreateContainer(opts)
-	return in.client.CreateContainer(opts)
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) StartContainer(id string, hostConfig *docker.HostConfig) error {
-	start := time.Now()
+	const operation = "start_container"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("start_container").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	err := in.client.StartContainer(id, hostConfig)
-	return in.client.StartContainer(id, hostConfig)
+	recordError(operation, err)
+	return err
 }
 
 func (in instrumentedDockerInterface) StopContainer(id string, timeout uint) error {
-	start := time.Now()
+	const operation = "stop_container"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("stop_container").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	err := in.client.StopContainer(id, timeout)
-	return in.client.StopContainer(id, timeout)
+	recordError(operation, err)
+	return err
 }
 
 func (in instrumentedDockerInterface) RemoveContainer(opts docker.RemoveContainerOptions) error {
-	start := time.Now()
+	const operation = "remove_container"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("remove_container").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	err := in.client.RemoveContainer(opts)
-	return in.client.RemoveContainer(opts)
+	recordError(operation, err)
+	return err
 }
 
 func (in instrumentedDockerInterface) InspectImage(image string) (*docker.Image, error) {
-	start := time.Now()
+	const operation = "inspect_image"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("inspect_image").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.InspectImage(image)
-	return in.client.InspectImage(image)
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) ListImages(opts docker.ListImagesOptions) ([]docker.APIImages, error) {
-	start := time.Now()
+	const operation = "list_images"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("list_images").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.ListImages(opts)
-	return in.client.ListImages(opts)
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) PullImage(opts docker.PullImageOptions, auth docker.AuthConfiguration) error {
-	start := time.Now()
+	const operation = "pull_image"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("pull_image").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	err := in.client.PullImage(opts, auth)
-	return in.client.PullImage(opts, auth)
+	recordError(operation, err)
+	return err
 }
 
 func (in instrumentedDockerInterface) RemoveImage(image string) error {
-	start := time.Now()
+	const operation = "remove_image"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("remove_image").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	err := in.client.RemoveImage(image)
-	return in.client.RemoveImage(image)
+	recordError(operation, err)
+	return err
 }
 
 func (in instrumentedDockerInterface) Logs(opts docker.LogsOptions) error {
-	start := time.Now()
+	const operation = "logs"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("logs").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	err := in.client.Logs(opts)
-	return in.client.Logs(opts)
+	recordError(operation, err)
+	return err
 }
 
 func (in instrumentedDockerInterface) Version() (*docker.Env, error) {
-	start := time.Now()
+	const operation = "version"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("version").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.Version()
-	return in.client.Version()
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) Info() (*docker.Env, error) {
-	start := time.Now()
+	const operation = "info"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("info").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.Info()
-	return in.client.Info()
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) CreateExec(opts docker.CreateExecOptions) (*docker.Exec, error) {
-	start := time.Now()
+	const operation = "create_exec"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("create_exec").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.CreateExec(opts)
-	return in.client.CreateExec(opts)
+	recordError(operation, err)
+	return out, err
 }
 
 func (in instrumentedDockerInterface) StartExec(startExec string, opts docker.StartExecOptions) error {
-	start := time.Now()
+	const operation = "start_exec"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("start_exec").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	err := in.client.StartExec(startExec, opts)
-	return in.client.StartExec(startExec, opts)
+	recordError(operation, err)
+	return err
 }
 
 func (in instrumentedDockerInterface) InspectExec(id string) (*docker.ExecInspect, error) {
-	start := time.Now()
+	const operation = "inspect_exec"
-	defer func() {
+	defer recordOperation(operation, time.Now())
-		metrics.DockerOperationsLatency.WithLabelValues("inspect_exec").Observe(metrics.SinceInMicroseconds(start))
+
-	}()
+	out, err := in.client.InspectExec(id)
-	return in.client.InspectExec(id)
+	recordError(operation, err)
+	return out, err
 }

pkg/kubelet/metrics/metrics.go

@@ -58,6 +58,14 @@ var (
 		},
 		[]string{"operation_type"},
 	)
+	DockerErrors = prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Subsystem: kubeletSubsystem,
+			Name:      "docker_errors",
+			Help:      "Cumulative number of Docker errors by operation type.",
+		},
+		[]string{"operation_type"},
+	)
 )
 
 var registerMetrics sync.Once
@@ -70,6 +78,7 @@ func Register(containerCache kubecontainer.RuntimeCache) {
 		prometheus.MustRegister(DockerOperationsLatency)
 		prometheus.MustRegister(SyncPodsLatency)
 		prometheus.MustRegister(ContainersPerPodCount)
+		prometheus.MustRegister(DockerErrors)
 		prometheus.MustRegister(newPodAndContainerCollector(containerCache))
 	})
 }