fix(drops): nil-map guard in DropSummary.Add + NoNUSignal category + test coverage (#875 CR)

- DropSummary.Add already had the lazy-init nil-map guard; add
  TestDropSummary_ZeroValue_Safe regression test to lock the behaviour
- Add DropFamilyNoNUSignal ("family-nu-no-nu-signal") constant and
  FamilyDropCounts.NoNUSignal field for the case where AWS-rec NU sums
  to zero (unknown/unrecognised sizes) -- distinct from AlreadyAtTarget
- Fix sizeRDSFamilyRecs: currentNU<=0 branch now sets NoNUSignal instead
  of incorrectly reusing AlreadyAtTarget
- Propagate NoNUSignal in ApplyFamilyNUSizingRDS aggregation loop and
  in cmd/multi_service_helpers.go drops recording
- Capture drops in all TestApplyFamilyNUSizingRDS subtests; assert
  AlreadyAtTarget==1 for the "at target" case, SizedToZero==1 for a
  new "floor(0)" test case, and zero total drops for passing-through cases

Author: cristim

cmd/multi_service_helpers.go

@@ -509,6 +509,7 @@ func applyCoverageAndOverrides(recs []common.Recommendation, cfg Config, coverag
 		var familyDrops recommendations.FamilyDropCounts
 		sizedRDS, rest, familyDrops = recommendations.ApplyFamilyNUSizingRDS(recs, coverageMap, cfg.TargetCoverage)
 		drops.Add(common.DropFamilyAlreadyAtTarget, familyDrops.AlreadyAtTarget)
+		drops.Add(common.DropFamilyNoNUSignal, familyDrops.NoNUSignal)
 		drops.Add(common.DropFamilySizedToZero, familyDrops.SizedToZero)
 	}
 	filteredRecs := applySizing(rest, cfg, cfg.Coverage, drops)

pkg/common/drop_summary.go

@@ -14,7 +14,8 @@ const (
 	DropTargetAlreadyMet    = "target-already-met"
 	DropTargetSizedToZero   = "target-sized-to-zero"
 	DropFamilyAlreadyAtTarget = "family-nu-already-at-target"
-	DropFamilySizedToZero   = "family-nu-sized-to-zero"
+	DropFamilyNoNUSignal     = "family-nu-no-nu-signal"
+	DropFamilySizedToZero    = "family-nu-sized-to-zero"
 	DropDuplicateDedup      = "duplicate-dedup"
 )
 

pkg/common/drop_summary_test.go

@@ -80,12 +80,13 @@ func TestDropSummary_FormatOneLine(t *testing.T) {
 				d.Add(DropTargetAlreadyMet, 3)
 				d.Add(DropTargetSizedToZero, 4)
 				d.Add(DropFamilyAlreadyAtTarget, 5)
-				d.Add(DropFamilySizedToZero, 6)
-				d.Add(DropDuplicateDedup, 7)
+				d.Add(DropFamilyNoNUSignal, 6)
+				d.Add(DropFamilySizedToZero, 7)
+				d.Add(DropDuplicateDedup, 8)
 			},
-			expected: "Dropped 28 recs: --include-extended-support=2, --min-pool-size=1, " +
-				"duplicate-dedup=7, family-nu-already-at-target=5, family-nu-sized-to-zero=6, " +
-				"target-already-met=3, target-sized-to-zero=4",
+			expected: "Dropped 36 recs: --include-extended-support=2, --min-pool-size=1, " +
+				"duplicate-dedup=8, family-nu-already-at-target=5, family-nu-no-nu-signal=6, " +
+				"family-nu-sized-to-zero=7, target-already-met=3, target-sized-to-zero=4",
 		},
 	}
 

providers/aws/recommendations/family_nu.go

@@ -138,6 +138,11 @@ type FamilyDropCounts struct {
 	// AlreadyAtTarget is the number of recs from families where the
 	// existing coverage already meets or exceeds the target (gap <= 0).
 	AlreadyAtTarget int
+	// NoNUSignal is the number of recs dropped because the family's
+	// AWS-recommended counts summed to zero NU (e.g. all recs at
+	// unknown/unrecognised sizes), so there is no scalable NU to apply
+	// the family target against. This is distinct from AlreadyAtTarget.
+	NoNUSignal int
 	// SizedToZero is the number of recs dropped because the family-wide
 	// scale factor produced a floor(0) count for that rec's size.
 	SizedToZero int
@@ -182,6 +187,7 @@ func ApplyFamilyNUSizingRDS(
 		sized, familyDrops := sizeRDSFamilyRecs(recs, indices, familyCov[fk], targetPct)
 		sizedRDS = append(sizedRDS, sized...)
 		drops.AlreadyAtTarget += familyDrops.AlreadyAtTarget
+		drops.NoNUSignal += familyDrops.NoNUSignal
 		drops.SizedToZero += familyDrops.SizedToZero
 	}
 	return sizedRDS, nonRDS, drops
@@ -254,8 +260,9 @@ func sizeRDSFamilyRecs(
 		currentNU += float64(recs[i].Count) * rdsInstanceNUFromType(recs[i].ResourceType)
 	}
 	if currentNU <= 0 {
-		// Recs sum to zero NU — nothing to scale.
-		drops.AlreadyAtTarget = len(indices)
+		// Recs sum to zero NU — family lookup returned no scalable signal.
+		// This is not the same as "already at target"; record separately.
+		drops.NoNUSignal = len(indices)
 		return nil, drops
 	}
 	scale := targetNU / currentNU

providers/aws/recommendations/family_nu_test.go

@@ -124,12 +124,13 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details: &common.DatabaseDetails{Engine: "aurora-mysql", AZConfig: "single-az"},
 			},
 		}
-		sized, nonRDS, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, nonRDS, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		require.Len(t, sized, 1, "RDS rec kept (target NU > 0)")
 		assert.Empty(t, nonRDS, "no non-RDS recs in this fixture")
 		assert.Equal(t, 15, sized[0].Count, "AWS-rec NU already matches target → count preserved")
 		// Costs unchanged (ratio = 1)
 		assert.InDelta(t, 1500.0, sized[0].CommitmentCost, 0.01)
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops expected")
 	})
 
 	t.Run("RecurringMonthlyCost scales with count when populated", func(t *testing.T) {
@@ -155,13 +156,14 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details:              &common.DatabaseDetails{Engine: "mysql", AZConfig: "multi-az"},
 			},
 		}
-		sized, _, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		require.Len(t, sized, 1)
 		// Scale 32/20 = 1.6 → newCount = 8 → monthly = 100 × 8/5 = 160
 		assert.Equal(t, 8, sized[0].Count)
 		require.NotNil(t, sized[0].RecurringMonthlyCost)
 		assert.InDelta(t, 160.0, *sized[0].RecurringMonthlyCost, 0.001, "monthly fee scales by 8/5 alongside other costs")
 		assert.Equal(t, 100.0, monthly, "original target should not be mutated (new pointer)")
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops expected")
 	})
 
 	t.Run("AWS rec under-recommends → counts scale up", func(t *testing.T) {
@@ -186,10 +188,11 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details:                     &common.DatabaseDetails{Engine: "mysql", AZConfig: "multi-az"},
 			},
 		}
-		sized, _, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		require.Len(t, sized, 1)
 		assert.Equal(t, 8, sized[0].Count, "scale 32/20 = 1.6 × 5 = 8 RIs to deliver 32 NU at 80% target")
 		assert.InDelta(t, 5000*8.0/5.0, sized[0].CommitmentCost, 0.01, "CommitmentCost scales by 8/5")
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops expected")
 	})
 
 	t.Run("AWS rec over-recommends → counts scale down", func(t *testing.T) {
@@ -212,9 +215,10 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details:        &common.DatabaseDetails{Engine: "mysql", AZConfig: "multi-az"},
 			},
 		}
-		sized, _, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		require.Len(t, sized, 1)
 		assert.Equal(t, 8, sized[0].Count, "AWS over-proposed; scale down to family target")
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops expected")
 	})
 
 	t.Run("family at-or-above target → all recs dropped", func(t *testing.T) {
@@ -234,8 +238,38 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details:        &common.DatabaseDetails{Engine: "aurora-mysql", AZConfig: "single-az"},
 			},
 		}
-		sized, _, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		assert.Empty(t, sized, "family already covered → drop all recs")
+		assert.Equal(t, 1, drops.AlreadyAtTarget, "one rec dropped as family-at-target")
+		assert.Equal(t, 0, drops.NoNUSignal+drops.SizedToZero, "no other drop categories")
+	})
+
+	t.Run("scale produces floor(0) for rec → SizedToZero drop", func(t *testing.T) {
+		// Family db.r7g Aurora MySQL us-east-1; cov=0, target=80 → target_NU=32.
+		// AWS rec: 1 × db.r7g.xlarge = 8 NU → scale = 32/8 = 4 — wait, that
+		// would scale up. Use a scenario where scale < 1 and count = 1:
+		// TotalNU = 10*4 = 40, existing=79% → gap=1 → targetNU=0.4.
+		// AWS rec: 1 × db.r7g.large = 4 NU → scale = 0.4/4 = 0.1 → floor(0.1) = 0.
+		cov := PoolCoverageMap{
+			rdsPoolKey("us-east-1", "db.r7g.large", "Aurora MySQL", "Single-AZ"): {
+				Pct: 79.0, AvgInstancesPerHour: 10,
+			},
+		}
+		recs := []common.Recommendation{
+			{
+				Service:        common.ServiceRDS,
+				CommitmentType: common.CommitmentReservedInstance,
+				Region:         "us-east-1",
+				ResourceType:   "db.r7g.large",
+				Count:          1,
+				CommitmentCost: 1000,
+				Details:        &common.DatabaseDetails{Engine: "aurora-mysql", AZConfig: "single-az"},
+			},
+		}
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		assert.Empty(t, sized, "rec scaled to zero → dropped")
+		assert.Equal(t, 1, drops.SizedToZero, "rec dropped because floor(scale*count)==0")
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal, "no other drop categories")
 	})
 
 	t.Run("no coverage signal → recs pass through unchanged", func(t *testing.T) {
@@ -251,9 +285,10 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details:        &common.DatabaseDetails{Engine: "aurora-mysql", AZConfig: "single-az"},
 			},
 		}
-		sized, _, _ := ApplyFamilyNUSizingRDS(recs, PoolCoverageMap{}, 80)
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, PoolCoverageMap{}, 80)
 		require.Len(t, sized, 1, "rec preserved as-is when no family-NU signal")
 		assert.Equal(t, 5, sized[0].Count)
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops when coverage map is empty")
 	})
 
 	t.Run("non-RDS recs flow through nonRDS partition", func(t *testing.T) {
@@ -276,11 +311,12 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Pct: 0.0, AvgInstancesPerHour: 10,
 			},
 		}
-		sized, nonRDS, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, nonRDS, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		require.Len(t, sized, 1, "only the RDS rec went through family-NU")
 		require.Len(t, nonRDS, 2, "EC2 + SP recs left for per-pool sizing")
 		assert.Equal(t, common.ServiceEC2, nonRDS[0].Service)
 		assert.Equal(t, common.ServiceSavingsPlans, nonRDS[1].Service)
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops expected")
 	})
 
 	t.Run("ProjectedCoverage is cumulative across recs in a family", func(t *testing.T) {
@@ -322,7 +358,7 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details:        &common.DatabaseDetails{Engine: "aurora-postgresql", AZConfig: "single-az"},
 			},
 		}
-		sized, _, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		require.Len(t, sized, 2, "both recs kept after scaling")
 		// Both recs see the SAME cumulative projection.
 		assert.InDelta(t, sized[0].ProjectedCoverage, sized[1].ProjectedCoverage, 0.001,
@@ -334,6 +370,7 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 		// Both rec.Count values reflect the scale-down.
 		assert.Equal(t, 4, sized[0].Count, "prod scaled 5→4")
 		assert.Equal(t, 2, sized[1].Count, "staging scaled 3→2")
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops expected")
 	})
 
 	t.Run("multiple sizes in same family scale together", func(t *testing.T) {
@@ -360,9 +397,10 @@ func TestApplyFamilyNUSizingRDS(t *testing.T) {
 				Details:        &common.DatabaseDetails{Engine: "aurora-mysql", AZConfig: "single-az"},
 			},
 		}
-		sized, _, _ := ApplyFamilyNUSizingRDS(recs, cov, 80)
+		sized, _, drops := ApplyFamilyNUSizingRDS(recs, cov, 80)
 		require.Len(t, sized, 1)
 		assert.Equal(t, 12, sized[0].Count, "family-NU need includes .xlarge demand even though AWS rec is at .large")
+		assert.Equal(t, 0, drops.AlreadyAtTarget+drops.NoNUSignal+drops.SizedToZero, "no drops expected")
 	})
 }