Return timeSaved metric even when cache restoration is skipped

cli/internal/cache/async_cache.go

@@ -54,7 +54,7 @@ func (c *asyncCache) Fetch(anchor turbopath.AbsoluteSystemPath, key string, file
 	return c.realCache.Fetch(anchor, key, files)
 }
 
-func (c *asyncCache) Exists(key string) ItemStatus {
+func (c *asyncCache) Exists(key string) (ItemStatus, int) {
 	return c.realCache.Exists(key)
 }
 

cli/internal/cache/cache.go

@@ -21,7 +21,7 @@ type Cache interface {
 	// Fetch returns true if there is a cache it. It is expected to move files
 	// into their correct position as a side effect
 	Fetch(anchor turbopath.AbsoluteSystemPath, hash string, files []string) (ItemStatus, []turbopath.AnchoredSystemPath, int, error)
-	Exists(hash string) ItemStatus
+	Exists(hash string) (ItemStatus, int)
 	// Put caches files for a given hash
 	Put(anchor turbopath.AbsoluteSystemPath, hash string, duration int, files []turbopath.AnchoredSystemPath) error
 	Clean(anchor turbopath.AbsoluteSystemPath)
@@ -271,6 +271,7 @@ func (mplex *cacheMultiplexer) Fetch(anchor turbopath.AbsoluteSystemPath, key st
 			// the operation. Future work that plumbs UI / Logging into the cache system
 			// should probably log this at least.
 		}
+
 		if ok {
 			// Store this into other caches. We can ignore errors here because we know
 			// we have previously successfully stored in a higher-priority cache, and so the overall
@@ -287,15 +288,26 @@ func (mplex *cacheMultiplexer) Fetch(anchor turbopath.AbsoluteSystemPath, key st
 	return ItemStatus{Local: false, Remote: false}, nil, 0, nil
 }
 
-func (mplex *cacheMultiplexer) Exists(target string) ItemStatus {
+func (mplex *cacheMultiplexer) Exists(target string) (ItemStatus, int) {
 	syncCacheState := ItemStatus{}
+	syncTimeSaved := 0
+
 	for _, cache := range mplex.caches {
-		itemStatus := cache.Exists(target)
+		itemStatus, timeSaved := cache.Exists(target)
+
 		syncCacheState.Local = syncCacheState.Local || itemStatus.Local
 		syncCacheState.Remote = syncCacheState.Remote || itemStatus.Remote
+
+		// If one of the caches saved more time, use that.
+		// TODO: it would make more sense to return the right value with the right cache,
+		// and then downstream pick the right cache to restore from, and then use _that_ timeSaved
+		// number, but that involves reworking the caching logic.
+		if timeSaved > syncTimeSaved {
+			syncTimeSaved = timeSaved
+		}
 	}
 
-	return syncCacheState
+	return syncCacheState, syncTimeSaved
 }
 
 func (mplex *cacheMultiplexer) Clean(anchor turbopath.AbsoluteSystemPath) {

cli/internal/cache/cache_fs.go

@@ -18,6 +18,7 @@ import (
 type fsCache struct {
 	cacheDirectory turbopath.AbsoluteSystemPath
 	recorder       analytics.Recorder
+	label          string
 }
 
 // newFsCache creates a new filesystem cache
@@ -27,6 +28,7 @@ func newFsCache(opts Opts, recorder analytics.Recorder, repoRoot turbopath.Absol
 		return nil, err
 	}
 	return &fsCache{
+		label:          CacheSourceFS,
 		cacheDirectory: cacheDir,
 		recorder:       recorder,
 	}, nil
@@ -74,15 +76,26 @@ func (f *fsCache) Fetch(anchor turbopath.AbsoluteSystemPath, hash string, _ []st
 	return ItemStatus{Local: true}, restoredFiles, meta.Duration, nil
 }
 
-func (f *fsCache) Exists(hash string) ItemStatus {
+// Exists returns the ItemStatus and the timeSaved
+func (f *fsCache) Exists(hash string) (ItemStatus, int) {
 	uncompressedCachePath := f.cacheDirectory.UntypedJoin(hash + ".tar")
 	compressedCachePath := f.cacheDirectory.UntypedJoin(hash + ".tar.zst")
 
+	status := ItemStatus{Local: false}
 	if compressedCachePath.FileExists() || uncompressedCachePath.FileExists() {
-		return ItemStatus{Local: true}
+		status.Local = true
 	}
 
-	return ItemStatus{Local: false}
+	// Swallow the error
+	var duration int
+	if meta, err := ReadCacheMetaFile(f.cacheDirectory.UntypedJoin(hash + "-meta.json")); err != nil {
+		return status, 0
+	} else {
+		duration = meta.Duration
+	}
+
+	return status, duration
+
 }
 
 func (f *fsCache) logFetch(hit bool, hash string, duration int) {

cli/internal/cache/cache_http.go

@@ -17,6 +17,8 @@ import (
 	"github.com/vercel/turbo/cli/internal/turbopath"
 )
 
+const durationHeaderName = "x-artifact-duration"
+
 type client interface {
 	PutArtifact(hash string, body []byte, duration int, tag string) error
 	FetchArtifact(hash string) (*http.Response, error)
@@ -31,6 +33,7 @@ type httpCache struct {
 	recorder       analytics.Recorder
 	signerVerifier *ArtifactSignatureAuthentication
 	repoRoot       turbopath.AbsoluteSystemPath
+	label          string
 }
 
 type limiter chan struct{}
@@ -104,14 +107,14 @@ func (cache *httpCache) Fetch(_ turbopath.AbsoluteSystemPath, key string, _ []st
 	return ItemStatus{Remote: hit}, files, duration, err
 }
 
-func (cache *httpCache) Exists(key string) ItemStatus {
+func (cache *httpCache) Exists(key string) (ItemStatus, int) {
 	cache.requestLimiter.acquire()
 	defer cache.requestLimiter.release()
-	hit, err := cache.exists(key)
+	hit, timeSaved, err := cache.exists(key)
 	if err != nil {
-		return ItemStatus{Remote: false}
+		return ItemStatus{Remote: false}, timeSaved
 	}
-	return ItemStatus{Remote: hit}
+	return ItemStatus{Remote: hit}, timeSaved
 }
 
 func (cache *httpCache) logFetch(hit bool, hash string, duration int) {
@@ -130,20 +133,30 @@ func (cache *httpCache) logFetch(hit bool, hash string, duration int) {
 	cache.recorder.LogEvent(payload)
 }
 
-func (cache *httpCache) exists(hash string) (bool, error) {
+func (cache *httpCache) exists(hash string) (bool, int, error) {
 	resp, err := cache.client.ArtifactExists(hash)
 	if err != nil {
-		return false, nil
+		return false, 0, nil
 	}
 
 	defer func() { err = resp.Body.Close() }()
 
 	if resp.StatusCode == http.StatusNotFound {
-		return false, nil
+		return false, 0, nil
 	} else if resp.StatusCode != http.StatusOK {
-		return false, fmt.Errorf("%s", strconv.Itoa(resp.StatusCode))
+		return false, 0, fmt.Errorf("%s", strconv.Itoa(resp.StatusCode))
 	}
-	return true, err
+
+	// If present, extract the duration from the response.
+	duration := 0
+	if resp.Header.Get(durationHeaderName) != "" {
+		// If we had an error reading the duration header, just swallow it for now.
+		if intVar, err := strconv.Atoi(resp.Header.Get(durationHeaderName)); err == nil {
+			duration = intVar
+		}
+	}
+
+	return true, duration, err
 }
 
 func (cache *httpCache) retrieve(hash string) (bool, []turbopath.AnchoredSystemPath, int, error) {
@@ -160,10 +173,10 @@ func (cache *httpCache) retrieve(hash string) (bool, []turbopath.AnchoredSystemP
 	}
 	// If present, extract the duration from the response.
 	duration := 0
-	if resp.Header.Get("x-artifact-duration") != "" {
-		intVar, err := strconv.Atoi(resp.Header.Get("x-artifact-duration"))
+	if resp.Header.Get(durationHeaderName) != "" {
+		intVar, err := strconv.Atoi(resp.Header.Get(durationHeaderName))
 		if err != nil {
-			return false, nil, 0, fmt.Errorf("invalid x-artifact-duration header: %w", err)
+			return false, nil, 0, fmt.Errorf("invalid %s header: %w", durationHeaderName, err)
 		}
 		duration = intVar
 	}
@@ -217,6 +230,7 @@ func (cache *httpCache) Shutdown() {}
 
 func newHTTPCache(opts Opts, client client, recorder analytics.Recorder, repoRoot turbopath.AbsoluteSystemPath) *httpCache {
 	return &httpCache{
+		label:          CacheSourceRemote,
 		writable:       true,
 		client:         client,
 		requestLimiter: make(limiter, 20),

cli/internal/cache/cache_noop.go

@@ -14,8 +14,8 @@ func (c *noopCache) Put(_ turbopath.AbsoluteSystemPath, _ string, _ int, _ []tur
 func (c *noopCache) Fetch(_ turbopath.AbsoluteSystemPath, _ string, _ []string) (ItemStatus, []turbopath.AnchoredSystemPath, int, error) {
 	return ItemStatus{Local: false, Remote: false}, nil, 0, nil
 }
-func (c *noopCache) Exists(_ string) ItemStatus {
-	return ItemStatus{}
+func (c *noopCache) Exists(_ string) (ItemStatus, int) {
+	return ItemStatus{}, 0
 }
 
 func (c *noopCache) Clean(_ turbopath.AbsoluteSystemPath) {}

cli/internal/client/cache.go

@@ -113,6 +113,7 @@ func (c *APIClient) getArtifact(hash string, httpMethod string) (*http.Response,
 	if allowAuth {
 		req.Header.Set("Authorization", "Bearer "+c.token)
 	}
+
 	req.Header.Set("User-Agent", c.userAgent())
 	if err != nil {
 		return nil, fmt.Errorf("invalid cache URL: %w", err)

cli/internal/run/dry_run.go

@@ -112,8 +112,8 @@ func populateCacheState(turboCache cache.Cache, taskSummaries []*runsummary.Task
 			defer wg.Done()
 			for index := range queue {
 				task := taskSummaries[index]
-				itemStatus := turboCache.Exists(task.Hash)
-				task.CacheSummary = runsummary.NewTaskCacheSummary(itemStatus, nil)
+				itemStatus, timeSaved := turboCache.Exists(task.Hash)
+				task.CacheSummary = runsummary.NewTaskCacheSummary(itemStatus, &timeSaved)
 			}
 		}()
 	}

cli/internal/runcache/runcache.go

@@ -156,6 +156,11 @@ func (tc *TaskCache) RestoreOutputs(ctx context.Context, prefixedUI *cli.Prefixe
 	} else {
 		// If outputs have not changed changed, that means we have a local cache hit.
 		cacheStatus.Local = true
+
+		// Check and assign timeSaved value.
+		_, saved := tc.rc.cache.Exists(tc.hash)
+		timeSaved = saved
+
 		prefixedUI.Warn(fmt.Sprintf("Configured outputs are already in place for %s, skipping cache check", tc.pt.TaskID))
 	}