Report only the latest remote config update in the status

An update carries the full current config set for a product, not a delta, so
the version and error recorded for it describe that update alone. Both were
accumulating instead: the version was a running maximum, so a config that was
removed or replaced by a lower-version one left a version reported as current
that no longer applied, and an apply error was never cleared, so a single
transient failure stayed in the status for the life of the process even after
the product recovered.

Reset both at the start of each update. The cumulative update counter still
accumulates, since that is what it is for.

Also stop importing pkg/config/remote/service from the status provider. It was
imported only to share the default instance name, and it drags uptane and
bbolt into every binary that links the provider, which showed up as six new
packages in process-agent. Repeating one string is much cheaper.

Assisted-by: Claude:claude-opus-5

Author: clamoriniere

comp/remote-config/rcstatus/impl/BUILD.bazel

@@ -14,7 +14,6 @@ go_library(
         "//comp/core/config",
         "//comp/core/status",
         "//comp/def",
-        "//pkg/config/remote/service",
         "//pkg/config/utils",
     ],
 )

comp/remote-config/rcstatus/impl/status.go

@@ -15,13 +15,17 @@ import (
 	"github.com/DataDog/datadog-agent/comp/core/config"
 	"github.com/DataDog/datadog-agent/comp/core/status"
 	compdef "github.com/DataDog/datadog-agent/comp/def"
-	remoteconfig "github.com/DataDog/datadog-agent/pkg/config/remote/service"
 	configutils "github.com/DataDog/datadog-agent/pkg/config/utils"
 )
 
 //go:embed status_templates
 var templatesFS embed.FS
 
+// defaultStatusInstance duplicates remoteconfig.DefaultStatusInstance rather
+// than importing it: that package drags uptane and bbolt into every binary
+// linking this one, which is far more expensive than repeating one string.
+const defaultStatusInstance = "Remote Config"
+
 // Requires holds the dependencies for the rcstatus component.
 type Requires struct {
 	compdef.In
@@ -104,7 +108,7 @@ func (rc statusProvider) populateStatus(stats map[string]interface{}) {
 	if instances, ok := status["instances"].(map[string]interface{}); ok {
 		additional := make(map[string]interface{}, len(instances))
 		for name, instance := range instances {
-			if name == remoteconfig.DefaultStatusInstance {
+			if name == defaultStatusInstance {
 				continue
 			}
 			additional[name] = instance

pkg/clusteragent/autoscaling/workload/status.go

@@ -80,6 +80,15 @@ func recordRemoteConfigUpdate(product string, timestamp time.Time, update map[st
 	tracked.LastUpdate = timestamp
 	tracked.ConfigCount = len(update)
 	tracked.UpdateCount++
+
+	// An update carries the full current config set for the product, not a
+	// delta, so both of these describe this update alone. Reset them rather
+	// than accumulating: a stale high version or a recovered error would
+	// otherwise be reported as current for the life of the process.
+	tracked.LastVersion = 0
+	tracked.LastError = ""
+	tracked.LastErrorTime = time.Time{}
+
 	for _, rawConfig := range update {
 		if rawConfig.Metadata.Version > tracked.LastVersion {
 			tracked.LastVersion = rawConfig.Metadata.Version

pkg/clusteragent/autoscaling/workload/status_test.go

@@ -122,3 +122,40 @@ func TestWorkloadAutoscalingStatusWithUpdates(t *testing.T) {
 	require.NoError(t, Provider{}.HTML(false, h))
 	assert.Contains(t, h.String(), "DatadogPodAutoscalers: 2")
 }
+
+// TestWorkloadAutoscalingStatusReportsOnlyTheLatestUpdate covers the two ways
+// stale state could leak into the status: an update carries the full config
+// set, so a version from a superseded config must not survive, and a recovered
+// product must not keep reporting an old error.
+func TestWorkloadAutoscalingStatusReportsOnlyTheLatestUpdate(t *testing.T) {
+	resetStatus(t)
+	cfg := configmock.New(t)
+	cfg.SetInTest("autoscaling.workload.enabled", true)
+	InitStatus(autoscalingstore.NewStore[model.PodAutoscalerInternal](), func() bool { return true }, "autoscaling")
+
+	now := time.Now()
+	// First update: high version, and a config that fails to apply.
+	recordRemoteConfigUpdate(data.ProductContainerAutoscalingSettings, now, map[string]state.RawConfig{
+		"a": {Metadata: state.Metadata{Version: 99}},
+	})
+	recordRemoteConfigError(data.ProductContainerAutoscalingSettings, now, errors.New("bad spec"))
+	out := renderText(t)
+	assert.Contains(t, out, "Last config version: 99")
+	assert.Contains(t, out, "Last error: bad spec")
+
+	// Second update: the high-version config is gone and nothing fails.
+	recordRemoteConfigUpdate(data.ProductContainerAutoscalingSettings, now.Add(time.Minute), map[string]state.RawConfig{
+		"b": {Metadata: state.Metadata{Version: 4}},
+	})
+	out = renderText(t)
+	assert.Contains(t, out, "Last config version: 4", "version must describe this update, not the highest ever seen")
+	assert.NotContains(t, out, "99")
+	assert.NotContains(t, out, "Last error:", "a recovered product must not keep reporting an old error")
+	assert.Contains(t, out, "Updates received: 2", "the cumulative counter still accumulates")
+
+	// An update that removes every config reports zero, not a stale version.
+	recordRemoteConfigUpdate(data.ProductContainerAutoscalingSettings, now.Add(2*time.Minute), map[string]state.RawConfig{})
+	out = renderText(t)
+	assert.Contains(t, out, "Configs in last update: 0")
+	assert.NotContains(t, out, "Last config version: 4")
+}