UsedVolumesSize and UsedStoreInBytes metrics

commands/clean.go

@@ -100,6 +100,12 @@ var CleanCommand = cli.Command{
 				logger.Error("getting-unused-volumes-size", err)
 			}
 			metricsEmitter.TryEmitUsage(logger, "UnusedLayersSize", unusedVolumesSize, "bytes")
+
+			usedVolumesSize, err := sm.UsedVolumesSize(logger)
+			if err != nil {
+				logger.Error("getting-used-volumes-size", err)
+			}
+			metricsEmitter.TryEmitUsage(logger, "UsedLayersSize", usedVolumesSize, "bytes")
 		}()
 
 		noop, err := cleaner.Clean(logger, cfg.Clean.ThresholdBytes)

commands/create.go

@@ -253,19 +253,25 @@ var CreateCommand = cli.Command{
 		}
 		fmt.Println(string(jsonBytes))
 
-		emitMetrics(logger, metricsEmitter, sm, cfg.Create.WithClean)
+		emitMetrics(logger, metricsEmitter, sm, cfg.Create.WithClean, storePath)
 
 		return nil
 	},
 }
 
-func emitMetrics(logger lager.Logger, metricsEmitter *metrics.Emitter, sm *storepkg.StoreMeasurer, cleanOnCreate bool) {
+func emitMetrics(logger lager.Logger, metricsEmitter *metrics.Emitter, sm *storepkg.StoreMeasurer, cleanOnCreate bool, storePath string) {
 	if !cleanOnCreate {
 		unusedVolumesSize, err := sm.UnusedVolumesSize(logger)
 		if err != nil {
 			logger.Info(fmt.Sprintf("getting-unused-layers-size: %s", err))
 		}
 		metricsEmitter.TryEmitUsage(logger, "UnusedLayersSize", unusedVolumesSize, "bytes")
+
+		usedVolumesSize, err := sm.UsedVolumesSize(logger)
+		if err != nil {
+			logger.Info(fmt.Sprintf("getting-used-layers-size: %s", err))
+		}
+		metricsEmitter.TryEmitUsage(logger, "UsedLayersSize", usedVolumesSize, "bytes")
 	}
 
 	totalVolumesSize, err := sm.TotalVolumesSize(logger)
@@ -279,6 +285,12 @@ func emitMetrics(logger lager.Logger, metricsEmitter *metrics.Emitter, sm *store
 		logger.Info(fmt.Sprintf("getting-commited-quota: %s", err))
 	}
 	metricsEmitter.TryEmitUsage(logger, "CommittedQuotaInBytes", commitedQuota, "bytes")
+
+	_, usedBackingStore, err := sm.PathStats(storePath)
+	if err != nil {
+		logger.Info(fmt.Sprintf("getting-store-stats: %s", err))
+	}
+	metricsEmitter.TryEmitUsage(logger, "UsedBackingStoreInBytes", usedBackingStore, "bytes")
 }
 
 func createFetcher(baseImageUrl *url.URL, systemContext types.SystemContext, createCfg config.Create) base_image_puller.Fetcher {

commands/delete.go

@@ -82,6 +82,12 @@ var DeleteCommand = cli.Command{
 				logger.Error("getting-unused-layers-size", err)
 			}
 			metricsEmitter.TryEmitUsage(logger, "UnusedLayersSize", unusedVolumesSize, "bytes")
+
+			usedVolumesSize, err := sm.UsedVolumesSize(logger)
+			if err != nil {
+				logger.Error("getting-used-layers-size", err)
+			}
+			metricsEmitter.TryEmitUsage(logger, "UsedLayersSize", usedVolumesSize, "bytes")
 		}()
 
 		err = deleter.Delete(logger, id)

groot/cleaner.go

@@ -1,7 +1,9 @@
 package groot
 
 import (
+	"fmt"
 	"time"
+	"fmt"
 
 	"code.cloudfoundry.org/lager"
 	errorspkg "github.com/pkg/errors"
@@ -42,10 +44,15 @@ func (c *cleaner) Clean(logger lager.Logger, threshold int64) (bool, error) {
 		if err != nil {
 			return false, errorspkg.Wrap(err, "failed to calculate committed quota")
 		}
+		logger.Debug(fmt.Sprintf("commitedQuota in bytes is: %d", committedQuota))
+
 		totalVolumesSize, err := c.storeMeasurer.TotalVolumesSize(logger)
 		if err != nil {
 			return false, errorspkg.Wrap(err, "failed to calculate total volumes size")
 		}
+		logger.Debug(fmt.Sprintf("totalVolumesSize in bytes is: %d", totalVolumesSize))
+		logger.Debug(fmt.Sprintf("threshold in bytes is: %d", threshold))
+
 		if (committedQuota + totalVolumesSize) < threshold {
 			return true, nil
 		}

store/measurer_linux.go

@@ -45,6 +45,20 @@ func (s *StoreMeasurer) UnusedVolumesSize(logger lager.Logger) (int64, error) {
 	return s.countVolumesSize(logger, unusedVols)
 }
 
+func (s *StoreMeasurer) UsedVolumesSize(logger lager.Logger) (int64, error) {
+
+	totalVolumesSize, err := s.TotalVolumesSize(logger)
+	if err != nil {
+		return 0, err
+	}
+	unusedVolumesSize, err := s.UnusedVolumesSize(logger)
+	if err != nil {
+		return 0, err
+	}
+	usedVolumesSize := totalVolumesSize - unusedVolumesSize
+	return usedVolumesSize, nil
+}
+
 func (s *StoreMeasurer) TotalVolumesSize(logger lager.Logger) (int64, error) {
 	vols, err := s.volumeDriver.Volumes(logger)
 	if err != nil {
@@ -114,7 +128,7 @@ func readImageQuota(imageDir string) (int64, error) {
 	return imageQuota, nil
 }
 
-func (s *StoreMeasurer) pathStats(path string) (totalBytes, UsedBytes int64, err error) {
+func (s *StoreMeasurer) PathStats(path string) (totalBytes, UsedBytes int64, err error) {
 	stats := syscall.Statfs_t{}
 	if err = syscall.Statfs(s.storePath, &stats); err != nil {
 		return 0, 0, errorspkg.Wrapf(err, "Invalid path %s", s.storePath)
@@ -127,3 +141,5 @@ func (s *StoreMeasurer) pathStats(path string) (totalBytes, UsedBytes int64, err
 
 	return int64(total), used, nil
 }
+
+

store/measurer_linux_test.go

@@ -95,6 +95,42 @@ var _ = Describe("Measurer", func() {
 		})
 	})
 
+	Describe("UsedVolumesSize", func() {
+		BeforeEach(func() {
+			volumeDriver.VolumeSizeReturns(1024, nil)
+			unusedVolumeGetter.UnusedVolumesReturns([]string{"sha256:fake1", "sha256:fake2"}, nil)
+			volumeDriver.VolumesReturns([]string{"sha256:fake1", "sha256:fake2"}, nil)
+		})
+
+		It("measures the size of the used layers", func() {
+			cacheUsage, err := storeMeasurer.UsedVolumesSize(logger)
+			Expect(err).NotTo(HaveOccurred())
+			Expect(cacheUsage).To(BeNumerically("==", 0))
+		})
+
+		Context("when getting total volumes returns an error", func() {
+			BeforeEach(func() {
+				volumeDriver.VolumesReturns([]string{}, errors.New("failed here"))
+			})
+
+			It("returns the error", func() {
+				_, err := storeMeasurer.TotalVolumesSize(logger)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+
+		Context("when getting unused volumes returns an error", func() {
+			BeforeEach(func() {
+				unusedVolumeGetter.UnusedVolumesReturns([]string{}, errors.New("failed here"))
+			})
+
+			It("returns the error", func() {
+				_, err := storeMeasurer.UnusedVolumesSize(logger)
+				Expect(err).To(HaveOccurred())
+			})
+		})
+	})
+
 	Describe("UnusedVolumeSize", func() {
 		BeforeEach(func() {
 			volumeDriver.VolumeSizeReturns(1024, nil)