Rename isSystem to isSystemWorker and add filterWorkers test coverage

- Rename local variable for clarity
- Add test for filterWorkers with includeSystemWorkers=false
- Annotate bool args with /*includeSystemWorkers*/ for readability

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: rkannan82

service/matching/workers/registry_impl.go

@@ -34,7 +34,7 @@ type (
 		hb             *workerpb.WorkerHeartbeat
 		lastSeen       time.Time
 		elem           *list.Element
-		isSystemWorker bool
+		isSystemWorkerWorker bool
 	}
 	// bucket holds part of the keyspace: a map from namespace → (map of instanceKey → entry),
 	// plus a recency list for eviction.
@@ -107,20 +107,20 @@ func (b *bucket) upsertHeartbeats(nsID namespace.ID, heartbeats []*workerpb.Work
 			continue
 		}
 
-		isSystem := primitives.IsInternalTaskQueue(hb.GetTaskQueue())
+		isSystemWorker := primitives.IsInternalTaskQueue(hb.GetTaskQueue())
 
 		// Normal upsert
 		if e, exists := mp[key]; exists {
 			e.hb = hb
 			e.lastSeen = now
-			e.isSystemWorker = isSystem
+			e.isSystemWorkerWorker = isSystemWorker
 			b.order.MoveToBack(e.elem)
 		} else {
 			e = &entry{
 				nsID:           nsID,
 				hb:             hb,
 				lastSeen:       now,
-				isSystemWorker: isSystem,
+				isSystemWorkerWorker: isSystemWorker,
 			}
 			e.elem = b.order.PushBack(e)
 			mp[key] = e
@@ -148,7 +148,7 @@ func (b *bucket) filterWorkers(
 	}
 	out := make([]*workerpb.WorkerHeartbeat, 0, len(mp))
 	for _, e := range mp {
-		if !includeSystemWorkers && e.isSystemWorker {
+		if !includeSystemWorkers && e.isSystemWorkerWorker {
 			continue
 		}
 		if predicate(e.hb) {

service/matching/workers/registry_impl_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	enumspb "go.temporal.io/api/enums/v1"
 	workerpb "go.temporal.io/api/worker/v1"
 	"go.temporal.io/server/common/dynamicconfig"
@@ -40,15 +41,15 @@ func TestUpdateAndListNamespace(t *testing.T) {
 	defer m.Stop()
 
 	// No entries initially
-	list := m.filterWorkers("ns1", true, alwaysTrue)
+	list := m.filterWorkers("ns1", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Empty(t, list, "expected empty list before updates")
 
 	// Add some heartbeats
 	hb1 := &workerpb.WorkerHeartbeat{WorkerInstanceKey: "workerA", Status: enumspb.WORKER_STATUS_RUNNING}
 	hb2 := &workerpb.WorkerHeartbeat{WorkerInstanceKey: "workerB", Status: enumspb.WORKER_STATUS_RUNNING}
 	m.upsertHeartbeats("ns1", []*workerpb.WorkerHeartbeat{hb1, hb2})
 
-	list = m.filterWorkers("ns1", true, alwaysTrue)
+	list = m.filterWorkers("ns1", true /*includeSystemWorkers*/,alwaysTrue)
 	// Order is not guaranteed; check contents by keys
 	keys := []string{list[0].WorkerInstanceKey, list[1].WorkerInstanceKey}
 	assert.Contains(t, keys, "workerA")
@@ -94,7 +95,7 @@ func TestShutdownStatusRemovesWorker(t *testing.T) {
 	m.upsertHeartbeats("ns1", []*workerpb.WorkerHeartbeat{hb1, hb2})
 
 	// Verify both workers are registered
-	list := m.filterWorkers("ns1", true, alwaysTrue)
+	list := m.filterWorkers("ns1", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Len(t, list, 2, "both workers should be registered")
 	assert.Equal(t, int64(2), m.total.Load(), "total should be 2")
 
@@ -103,7 +104,7 @@ func TestShutdownStatusRemovesWorker(t *testing.T) {
 	m.upsertHeartbeats("ns1", []*workerpb.WorkerHeartbeat{hbShutdown})
 
 	// Verify only worker1 is removed, worker2 remains
-	list = m.filterWorkers("ns1", true, alwaysTrue)
+	list = m.filterWorkers("ns1", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Len(t, list, 1, "only one worker should remain")
 	assert.Equal(t, "worker2", list[0].WorkerInstanceKey, "worker2 should remain")
 	assert.Equal(t, int64(1), m.total.Load(), "total should be 1 after shutdown")
@@ -141,7 +142,7 @@ func TestShutdownStatusForNonExistentWorker(t *testing.T) {
 	m.upsertHeartbeats("ns1", []*workerpb.WorkerHeartbeat{hb})
 
 	// Verify nothing happened
-	list := m.filterWorkers("ns1", true, alwaysTrue)
+	list := m.filterWorkers("ns1", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Empty(t, list, "no workers should exist")
 	assert.Zero(t, m.total.Load(), "total should remain 0")
 }
@@ -180,12 +181,36 @@ func TestListNamespacePredicate(t *testing.T) {
 
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
-			list := m.filterWorkers("ns", true, tc.pred)
+			list := m.filterWorkers("ns", true /*includeSystemWorkers*/,tc.pred)
 			assert.Len(t, list, tc.wantCount)
 		})
 	}
 }
 
+func TestFilterWorkersExcludesSystemWorkers(t *testing.T) {
+	m := newRegistryImpl(testDefaultRegistryParams(metrics.NoopMetricsHandler))
+	defer m.Stop()
+
+	m.upsertHeartbeats("ns", []*workerpb.WorkerHeartbeat{
+		{WorkerInstanceKey: "user-1", TaskQueue: "my-queue"},
+		{WorkerInstanceKey: "user-2", TaskQueue: "my-queue"},
+		{WorkerInstanceKey: "sys-1", TaskQueue: "temporal-sys-per-ns-tq"},
+	})
+
+	t.Run("includeSystemWorkers=true returns all", func(t *testing.T) {
+		list := m.filterWorkers("ns", true /*includeSystemWorkers*/, alwaysTrue)
+		require.Len(t, list, 3)
+	})
+
+	t.Run("includeSystemWorkers=false excludes system workers", func(t *testing.T) {
+		list := m.filterWorkers("ns", false /*includeSystemWorkers*/, alwaysTrue)
+		require.Len(t, list, 2)
+		for _, w := range list {
+			require.NotEqual(t, "sys-1", w.WorkerInstanceKey)
+		}
+	})
+}
+
 func TestEvictByTTL(t *testing.T) {
 	// Use capture handler to verify metrics
 	captureHandler := metricstest.NewCaptureHandler()
@@ -216,7 +241,7 @@ func TestEvictByTTL(t *testing.T) {
 	// Perform eviction
 	m.evictByTTL()
 
-	list := m.filterWorkers("ns", true, alwaysTrue)
+	list := m.filterWorkers("ns", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Empty(t, list, "entry should be evicted by TTL")
 	assert.Zero(t, m.total.Load(), "total counter should be decremented")
 
@@ -261,7 +286,7 @@ func TestEvictByCapacity(t *testing.T) {
 	m.evictByCapacity()
 
 	// Ensure we evicted down to maxItems
-	remaining := m.filterWorkers("ns", true, alwaysTrue)
+	remaining := m.filterWorkers("ns", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Len(t, remaining, int(maxItems), "should evict down to maxItems")
 	assert.LessOrEqual(t, m.total.Load(), int64(maxItems), "total counter should not exceed maxItems")
 
@@ -323,7 +348,7 @@ func TestEvictByCapacityWithMinAgeProtection(t *testing.T) {
 	m.evictByCapacity()
 
 	// All entries should still be there (protected by minEvictAge)
-	workers := m.filterWorkers("ns", true, alwaysTrue)
+	workers := m.filterWorkers("ns", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Len(t, workers, 3, "all entries should be protected by minEvictAge")
 	assert.Equal(t, int64(3), m.total.Load(), "should still exceed maxItems due to protection")
 
@@ -374,7 +399,7 @@ func TestEvictByCapacityAfterMinAge(t *testing.T) {
 		m.evictByCapacity()
 
 		// Should have evicted down to maxItems
-		workers := m.filterWorkers("ns", true, alwaysTrue)
+		workers := m.filterWorkers("ns", true /*includeSystemWorkers*/,alwaysTrue)
 		assert.LessOrEqual(t, len(workers), int(maxItems), "should evict down to maxItems")
 		assert.LessOrEqual(t, m.total.Load(), int64(maxItems), "total should be within limits")
 
@@ -424,10 +449,10 @@ func TestMultipleNamespaces(t *testing.T) {
 	m.upsertHeartbeats("namespace2", ns2Workers)
 
 	// Verify functional behavior first
-	ns1List := m.filterWorkers("namespace1", true, alwaysTrue)
+	ns1List := m.filterWorkers("namespace1", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Len(t, ns1List, 3, "namespace1 should have 3 workers")
 
-	ns2List := m.filterWorkers("namespace2", true, alwaysTrue)
+	ns2List := m.filterWorkers("namespace2", true /*includeSystemWorkers*/,alwaysTrue)
 	assert.Len(t, ns2List, 2, "namespace2 should have 2 workers")
 
 	assert.Equal(t, int64(5), m.total.Load(), "total should be 5 workers across namespaces")
@@ -548,7 +573,7 @@ func BenchmarkListNamespace(b *testing.B) {
 	}
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
-		_ = m.filterWorkers("benchNs", true, alwaysTrue)
+		_ = m.filterWorkers("benchNs", true /*includeSystemWorkers*/,alwaysTrue)
 	}
 }