feat(cache-analytics): add DataSource dimension to analytics events

Plumbs the owning subgraph name through every analytics event so a single
entity instance resolved by multiple subgraphs can be attributed correctly
in dashboards (a User id=42 may have N L2 cache entries — one per subgraph
that contributes fields — and EntityType alone cannot disambiguate them).

- DataSource string field on EntityFieldHash, MutationEvent,
  entitySourceRecord
- HashFieldValue, RecordEntitySource, walkCachedResponseForSources
  signatures gain a dataSource parameter
- New EntityDataSource(entityType, keyJSON) lookup mirrors EntitySource
- Resolvable.currentEntityDataSource is saved/restored across nested
  entities; resolved from the loader-phase entitySources record, falling
  back to obj.SourceName for cold subgraph fetches that never hit L1/L2

Author: SkArchon

v2/pkg/engine/resolve/cache_analytics.go

@@ -107,6 +107,7 @@ type EntityFieldHash struct {
 	KeyRaw     string      // raw key JSON e.g. {"id":"1234"} (when HashKeys=false)
 	KeyHash    uint64      // xxhash of key JSON (when HashKeys=true)
 	Source     FieldSource // where the entity data came from (L1/L2/Subgraph)
+	DataSource string      // subgraph name that owns this entity (empty if not resolvable)
 }
 
 // EntityTypeInfo holds the entity type name and its instance count.
@@ -128,6 +129,7 @@ type entitySourceRecord struct {
 	entityType string
 	keyJSON    string
 	source     FieldSource
+	dataSource string // subgraph name (empty if unknown)
 }
 
 // ShadowComparisonEvent records a comparison between cached and fresh data in shadow mode.
@@ -152,6 +154,7 @@ type MutationEvent struct {
 	Timestamp         time.Time // when the mutation was observed; stamped by RecordMutationEvent if zero
 	MutationRootField string    // e.g., "updateUsername"
 	EntityType        string    // e.g., "User"
+	DataSource        string    // subgraph name that owns the mutated entity (empty when not resolvable)
 	EntityCacheKey    string    // display key e.g. {"__typename":"User","key":{"id":"1234"}}
 	HadCachedValue    bool      // true if L2 had a cached value for this entity
 	IsStale           bool      // true if cached value differs from mutation response (always false when HadCachedValue=false)
@@ -313,8 +316,9 @@ func (c *CacheAnalyticsCollector) RecordWrite(event CacheWriteEvent) {
 }
 
 // HashFieldValue computes an xxhash of the given field value bytes and records it
-// as an EntityFieldHash with entity key and source information.
-func (c *CacheAnalyticsCollector) HashFieldValue(entityType, fieldName string, valueBytes []byte, keyRaw string, keyHash uint64, source FieldSource) {
+// as an EntityFieldHash with entity key and source information. dataSource is
+// the subgraph name that owns the entity (may be empty if not resolvable).
+func (c *CacheAnalyticsCollector) HashFieldValue(entityType, fieldName string, valueBytes []byte, keyRaw string, keyHash uint64, source FieldSource, dataSource string) {
 	c.xxh.Reset()
 	_, _ = c.xxh.Write(valueBytes)
 	hash := c.xxh.Sum64()
@@ -327,6 +331,7 @@ func (c *CacheAnalyticsCollector) HashFieldValue(entityType, fieldName string, v
 		KeyRaw:     keyRaw,
 		KeyHash:    keyHash,
 		Source:     source,
+		DataSource: dataSource,
 	})
 }
 
@@ -353,12 +358,13 @@ func (c *CacheAnalyticsCollector) IncrementEntityCount(typeName string, keyJSON
 }
 
 // RecordEntitySource records the source of data for a specific entity instance.
-// Main thread only.
-func (c *CacheAnalyticsCollector) RecordEntitySource(entityType, keyJSON string, source FieldSource) {
+// Main thread only. dataSource is the subgraph name (may be empty).
+func (c *CacheAnalyticsCollector) RecordEntitySource(entityType, keyJSON, dataSource string, source FieldSource) {
 	c.entitySources = append(c.entitySources, entitySourceRecord{
 		entityType: entityType,
 		keyJSON:    keyJSON,
 		source:     source,
+		dataSource: dataSource,
 	})
 }
 
@@ -448,6 +454,17 @@ func (c *CacheAnalyticsCollector) EntitySource(entityType, keyJSON string) Field
 	return FieldSourceSubgraph
 }
 
+// EntityDataSource returns the subgraph name that owns a given entity instance.
+// Returns "" if no record is found.
+func (c *CacheAnalyticsCollector) EntityDataSource(entityType, keyJSON string) string {
+	for i := len(c.entitySources) - 1; i >= 0; i-- {
+		if c.entitySources[i].entityType == entityType && c.entitySources[i].keyJSON == keyJSON {
+			return c.entitySources[i].dataSource
+		}
+	}
+	return ""
+}
+
 // Snapshot produces a read-only CacheAnalyticsSnapshot from the collected data.
 // Duplicate events (same cache key appearing multiple times due to entity batch positions)
 // are consolidated: consumers see one event per unique (CacheKey, Kind) for reads,
@@ -1065,14 +1082,15 @@ func appendKeyFieldsJSON(buf []byte, value *astjson.Value, keyFields []KeyField)
 
 // walkCachedResponseForSources walks a cached JSON value to find entity instances
 // and accumulates their source records on a per-result slice (goroutine-safe).
-func walkCachedResponseForSources(value *astjson.Value, keyFields []KeyField, entityType string, source FieldSource, out *[]entitySourceRecord) {
+// dataSource is the subgraph name the cached response originated from (may be empty).
+func walkCachedResponseForSources(value *astjson.Value, keyFields []KeyField, entityType, dataSource string, source FieldSource, out *[]entitySourceRecord) {
 	if value == nil {
 		return
 	}
 	switch value.Type() {
 	case astjson.TypeArray:
 		for _, item := range value.GetArray() {
-			walkCachedResponseForSources(item, keyFields, entityType, source, out)
+			walkCachedResponseForSources(item, keyFields, entityType, dataSource, source, out)
 		}
 	case astjson.TypeObject:
 		keyJSON := buildEntityKeyJSON(value, keyFields)
@@ -1081,6 +1099,7 @@ func walkCachedResponseForSources(value *astjson.Value, keyFields []KeyField, en
 				entityType: entityType,
 				keyJSON:    string(keyJSON),
 				source:     source,
+				dataSource: dataSource,
 			})
 		}
 	}

v2/pkg/engine/resolve/cache_analytics_test.go

@@ -136,8 +136,8 @@ func TestCacheAnalyticsCollector_FieldHashing(t *testing.T) {
 	t.Run("same input produces same hash", func(t *testing.T) {
 		c := NewCacheAnalyticsCollector()
 
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph)
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph)
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph, "")
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph, "")
 
 		snap := c.Snapshot()
 		assert.Equal(t, 2, len(snap.FieldHashes))
@@ -151,8 +151,8 @@ func TestCacheAnalyticsCollector_FieldHashing(t *testing.T) {
 	t.Run("different input produces different hash", func(t *testing.T) {
 		c := NewCacheAnalyticsCollector()
 
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph)
-		c.HashFieldValue("User", "name", []byte(`"Bob"`), `{"id":"2"}`, 0, FieldSourceSubgraph)
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph, "")
+		c.HashFieldValue("User", "name", []byte(`"Bob"`), `{"id":"2"}`, 0, FieldSourceSubgraph, "")
 
 		snap := c.Snapshot()
 		assert.Equal(t, 2, len(snap.FieldHashes))
@@ -162,7 +162,7 @@ func TestCacheAnalyticsCollector_FieldHashing(t *testing.T) {
 	t.Run("hashed keys mode", func(t *testing.T) {
 		c := NewCacheAnalyticsCollector()
 
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), "", 12345, FieldSourceL1)
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), "", 12345, FieldSourceL1, "")
 
 		snap := c.Snapshot()
 		assert.Equal(t, 1, len(snap.FieldHashes))
@@ -174,9 +174,9 @@ func TestCacheAnalyticsCollector_FieldHashing(t *testing.T) {
 	t.Run("field source tracking", func(t *testing.T) {
 		c := NewCacheAnalyticsCollector()
 
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph)
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceL1)
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceL2)
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph, "")
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceL1, "")
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceL2, "")
 
 		snap := c.Snapshot()
 		assert.Equal(t, 3, len(snap.FieldHashes))
@@ -234,9 +234,9 @@ func TestCacheAnalyticsCollector_EntityCounts(t *testing.T) {
 func TestCacheAnalyticsCollector_EntitySourceTracking(t *testing.T) {
 	c := NewCacheAnalyticsCollector()
 
-	c.RecordEntitySource("User", `{"id":"1"}`, FieldSourceSubgraph)
-	c.RecordEntitySource("User", `{"id":"2"}`, FieldSourceL1)
-	c.RecordEntitySource("Product", `{"upc":"top-1"}`, FieldSourceL2)
+	c.RecordEntitySource("User", `{"id":"1"}`, "", FieldSourceSubgraph)
+	c.RecordEntitySource("User", `{"id":"2"}`, "", FieldSourceL1)
+	c.RecordEntitySource("Product", `{"upc":"top-1"}`, "", FieldSourceL2)
 
 	assert.Equal(t, FieldSourceSubgraph, c.EntitySource("User", `{"id":"1"}`))
 	assert.Equal(t, FieldSourceL1, c.EntitySource("User", `{"id":"2"}`))
@@ -1564,7 +1564,7 @@ func TestFieldSourceShadowCached(t *testing.T) {
 	t.Run("HashFieldValue with FieldSourceShadowCached", func(t *testing.T) {
 		c := NewCacheAnalyticsCollector()
 
-		c.HashFieldValue("User", "username", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceShadowCached)
+		c.HashFieldValue("User", "username", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceShadowCached, "")
 
 		snap := c.Snapshot()
 		require.Equal(t, 1, len(snap.FieldHashes))
@@ -1577,8 +1577,8 @@ func TestFieldSourceShadowCached(t *testing.T) {
 	t.Run("can distinguish from other sources", func(t *testing.T) {
 		c := NewCacheAnalyticsCollector()
 
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph)
-		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceShadowCached)
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceSubgraph, "")
+		c.HashFieldValue("User", "name", []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceShadowCached, "")
 
 		snap := c.Snapshot()
 		require.Equal(t, 2, len(snap.FieldHashes))
@@ -1755,7 +1755,7 @@ func BenchmarkFieldHashing(b *testing.B) {
 
 	b.ResetTimer()
 	for b.Loop() {
-		c.HashFieldValue("User", "id", value, `{"id":"1"}`, 0, FieldSourceSubgraph)
+		c.HashFieldValue("User", "id", value, `{"id":"1"}`, 0, FieldSourceSubgraph, "")
 	}
 }
 
@@ -2056,7 +2056,7 @@ func TestSnapshotSlicesAreIndependent(t *testing.T) {
 	c.RecordError(SubgraphErrorEvent{DataSource: "ds-orig"})
 	c.RecordMutationEvent(MutationEvent{EntityType: "User-orig"})
 	c.RecordCacheOperationError(CacheOperationError{DataSource: "ds-orig"})
-	c.HashFieldValue("User-orig", "name", []byte(`"a"`), "k-orig", 1, FieldSourceL1)
+	c.HashFieldValue("User-orig", "name", []byte(`"a"`), "k-orig", 1, FieldSourceL1, "")
 
 	snap := c.Snapshot()
 
@@ -2078,7 +2078,7 @@ func TestSnapshotSlicesAreIndependent(t *testing.T) {
 		c.RecordError(SubgraphErrorEvent{DataSource: "ds-new"})
 		c.RecordMutationEvent(MutationEvent{EntityType: "User-new"})
 		c.RecordCacheOperationError(CacheOperationError{DataSource: "ds-new"})
-		c.HashFieldValue("User-new", "name", []byte(`"z"`), "k-new", 2, FieldSourceL2)
+		c.HashFieldValue("User-new", "name", []byte(`"z"`), "k-new", 2, FieldSourceL2, "")
 	}
 
 	// Full-slice assertions — snapshot must still show the original events.
@@ -2175,3 +2175,88 @@ func TestCacheAnalyticsCollector_TimestampsPreservePreSet(t *testing.T) {
 	}
 }
 
+// TestCacheAnalyticsCollector_DataSourceOnHashFieldValue verifies that the
+// dataSource argument is recorded on EntityFieldHash. Without this, dashboards
+// cannot attribute a field hash to the subgraph that produced the data when
+// multiple subgraphs contribute fields to the same entity.
+func TestCacheAnalyticsCollector_DataSourceOnHashFieldValue(t *testing.T) {
+	c := NewCacheAnalyticsCollector()
+
+	// Same entity (User id=1) resolved by two subgraphs — the field-hash
+	// records must distinguish which subgraph each value came from.
+	c.HashFieldValue("User", "name", nil, []byte(`"Alice"`), `{"id":"1"}`, 0, FieldSourceL2, "accounts")
+	c.HashFieldValue("User", "reviews", nil, []byte(`[]`), `{"id":"1"}`, 0, FieldSourceSubgraph, "reviews")
+
+	snap := c.Snapshot()
+	require.Equal(t, 2, len(snap.FieldHashes))
+	assert.Equal(t, "accounts", snap.FieldHashes[0].DataSource, "first hash attributes to accounts subgraph")
+	assert.Equal(t, "reviews", snap.FieldHashes[1].DataSource, "second hash attributes to reviews subgraph")
+}
+
+// TestCacheAnalyticsCollector_EntityDataSource verifies the EntityDataSource
+// reverse lookup returns the recorded subgraph and "" for unknown entities.
+// Last-write-wins on duplicate keys, mirroring EntitySource semantics.
+func TestCacheAnalyticsCollector_EntityDataSource(t *testing.T) {
+	c := NewCacheAnalyticsCollector()
+
+	// Three distinct entities owned by three subgraphs.
+	c.RecordEntitySource("User", `{"id":"1"}`, "accounts", FieldSourceSubgraph)
+	c.RecordEntitySource("Product", `{"upc":"top-1"}`, "products", FieldSourceL2)
+	c.RecordEntitySource("Review", `{"id":"r1"}`, "reviews", FieldSourceL1)
+
+	assert.Equal(t, "accounts", c.EntityDataSource("User", `{"id":"1"}`))
+	assert.Equal(t, "products", c.EntityDataSource("Product", `{"upc":"top-1"}`))
+	assert.Equal(t, "reviews", c.EntityDataSource("Review", `{"id":"r1"}`))
+	assert.Equal(t, "", c.EntityDataSource("Unknown", `{"id":"99"}`), "unknown entity returns empty string")
+
+	// Last-write-wins: a second record for the same (type, key) overrides.
+	c.RecordEntitySource("User", `{"id":"1"}`, "accounts-v2", FieldSourceL1)
+	assert.Equal(t, "accounts-v2", c.EntityDataSource("User", `{"id":"1"}`), "most recent record wins")
+}
+
+// TestCacheAnalyticsCollector_MutationEventDataSource verifies that DataSource
+// is preserved through RecordMutationEvent. Mutation analytics need to know
+// which subgraph owns the mutated entity for cross-subgraph dashboards.
+func TestCacheAnalyticsCollector_MutationEventDataSource(t *testing.T) {
+	c := NewCacheAnalyticsCollector()
+
+	c.RecordMutationEvent(MutationEvent{
+		MutationRootField: "updateUsername",
+		EntityType:        "User",
+		DataSource:        "accounts",
+		EntityCacheKey:    `{"__typename":"User","key":{"id":"1"}}`,
+		HadCachedValue:    true,
+		IsStale:           true,
+	})
+
+	snap := c.Snapshot()
+	require.Equal(t, 1, len(snap.MutationEvents))
+	assert.Equal(t, "accounts", snap.MutationEvents[0].DataSource)
+}
+
+// TestWalkCachedResponseForSources_DataSource verifies that
+// walkCachedResponseForSources propagates the dataSource argument to every
+// entity record it produces while traversing a cached JSON value. Without
+// this propagation, L2 cache hits would land in entitySources without
+// subgraph attribution and the resolvable would have to fall back to
+// obj.SourceName for every entity rendered from cache.
+func TestWalkCachedResponseForSources_DataSource(t *testing.T) {
+	a := arena.NewMonotonicArena(arena.WithMinBufferSize(1024))
+	parser := &astjson.Parser{}
+
+	value, err := parser.ParseBytesWithArena(a, []byte(`[{"id":"1","name":"Alice"},{"id":"2","name":"Bob"}]`))
+	require.NoError(t, err)
+
+	keyFields := []KeyField{{Name: "id"}}
+	var sources []entitySourceRecord
+
+	walkCachedResponseForSources(value, keyFields, "User", "accounts", FieldSourceL2, &sources)
+
+	require.Equal(t, 2, len(sources))
+	for i, want := range []string{`{"id":"1"}`, `{"id":"2"}`} {
+		assert.Equal(t, "User", sources[i].entityType)
+		assert.Equal(t, want, sources[i].keyJSON)
+		assert.Equal(t, FieldSourceL2, sources[i].source)
+		assert.Equal(t, "accounts", sources[i].dataSource, "every entity record must carry the dataSource")
+	}
+}

v2/pkg/engine/resolve/loader_cache.go

@@ -958,7 +958,7 @@ func (l *Loader) tryL1CacheLoad(info *FetchInfo, cacheKeys []*CacheKey, res *res
 					if len(res.cacheConfig.KeyFields) > 0 {
 						keyJSON := buildEntityKeyJSON(cachedValue, res.cacheConfig.KeyFields)
 						if len(keyJSON) > 0 {
-							l.ctx.cacheAnalytics.RecordEntitySource(entityType, string(keyJSON), FieldSourceL1)
+							l.ctx.cacheAnalytics.RecordEntitySource(entityType, string(keyJSON), dataSource, FieldSourceL1)
 						}
 					}
 				}
@@ -1515,6 +1515,17 @@ func (l *Loader) applyEntityFetchL2Results(info *FetchInfo, res *result, state l
 		res.l2CacheKeys[i].fromCacheRemainingTTL = res.l1CacheKeys[i].fromCacheRemainingTTL
 		res.l2CacheKeys[i].fromCacheNeedsWriteback = res.l1CacheKeys[i].fromCacheNeedsWriteback
 
+		// Extract the entity key from the schema-shape value BEFORE
+		// denormalization. cacheConfig.KeyFields are schema names; once
+		// aliases are reapplied, an `id` key field would no longer match a
+		// `userId: id` aliased field and the entitySourceRecord would be
+		// silently dropped, leaving EntitySource / EntityDataSource lookups
+		// to fall back to defaults for cached alias reads.
+		var preDenormKeyJSON []byte
+		if state.analyticsEnabled && len(res.cacheConfig.KeyFields) > 0 && len(res.l1CacheKeys[i].Keys) > 0 {
+			preDenormKeyJSON = buildEntityKeyJSON(res.l1CacheKeys[i].FromCache, res.cacheConfig.KeyFields)
+		}
+
 		if state.hasAliases {
 			res.l1CacheKeys[i].FromCache = l.structuralCopyDenormalizedPassthrough(res.l1CacheKeys[i].FromCache, res.providesData)
 		}
@@ -1534,13 +1545,10 @@ func (l *Loader) applyEntityFetchL2Results(info *FetchInfo, res *result, state l
 				Kind: CacheKeyHit, DataSource: state.dataSource, ByteSize: byteSize,
 				CacheAgeMs: cacheAgeMs, Shadow: state.shadowMode,
 			})
-			if len(res.cacheConfig.KeyFields) > 0 {
-				keyJSON := buildEntityKeyJSON(res.l1CacheKeys[i].FromCache, res.cacheConfig.KeyFields)
-				if len(keyJSON) > 0 {
-					res.l2EntitySources = append(res.l2EntitySources, entitySourceRecord{
-						entityType: state.entityType, keyJSON: string(keyJSON), source: FieldSourceL2,
-					})
-				}
+			if len(preDenormKeyJSON) > 0 {
+				res.l2EntitySources = append(res.l2EntitySources, entitySourceRecord{
+					entityType: state.entityType, keyJSON: string(preDenormKeyJSON), source: FieldSourceL2, dataSource: state.dataSource,
+				})
 			}
 		}
 
@@ -1652,6 +1660,16 @@ func (l *Loader) applyRootFetchL2Results(info *FetchInfo, res *result, state l2C
 			continue
 		}
 
+		// Walk the schema-shape value for entitySourceRecord emission BEFORE
+		// denormalization. cacheConfig.KeyFields are schema names; once
+		// aliases are reapplied, an `id` key field would no longer match a
+		// `userId: id` aliased field and entity-source records would be
+		// silently dropped, leaving EntitySource / EntityDataSource lookups
+		// to fall back to defaults for cached alias reads.
+		if state.analyticsEnabled && len(res.cacheConfig.KeyFields) > 0 && len(ck.Keys) > 0 {
+			walkCachedResponseForSources(ck.FromCache, res.cacheConfig.KeyFields, state.entityType, state.dataSource, FieldSourceL2, &res.l2EntitySources)
+		}
+
 		if state.hasAliases {
 			if res.batchEntityKeyMode && state.batchEntityProvidesData != nil {
 				res.l2CacheKeys[i].FromCache = l.structuralCopyDenormalized(ck.FromCache, state.batchEntityProvidesData)
@@ -1672,9 +1690,6 @@ func (l *Loader) applyRootFetchL2Results(info *FetchInfo, res *result, state l2C
 				Kind: CacheKeyHit, DataSource: state.dataSource, ByteSize: byteSize,
 				CacheAgeMs: cacheAgeMs, Shadow: state.shadowMode,
 			})
-			if len(res.cacheConfig.KeyFields) > 0 {
-				walkCachedResponseForSources(res.l2CacheKeys[i].FromCache, res.cacheConfig.KeyFields, state.entityType, FieldSourceL2, &res.l2EntitySources)
-			}
 		}
 
 		if state.tracingCache {
@@ -2557,7 +2572,7 @@ func (l *Loader) compareShadowValues(res *result, info *FetchInfo) {
 					fieldBytes := fieldVal.MarshalTo(nil)
 					l.ctx.cacheAnalytics.HashFieldValue(
 						entityType, fieldName, fieldBytes,
-						keyRaw, 0, FieldSourceShadowCached,
+						keyRaw, 0, FieldSourceShadowCached, dataSource,
 					)
 				}
 			}
@@ -2724,6 +2739,7 @@ func (l *Loader) detectSingleMutationEntityImpact(
 	l.ctx.cacheAnalytics.RecordMutationEvent(MutationEvent{
 		MutationRootField: mutationFieldName,
 		EntityType:        cfg.EntityTypeName,
+		DataSource:        info.DataSourceName,
 		EntityCacheKey:    displayKey,
 		HadCachedValue:    false,
 		IsStale:           false,