tweak counts

Author: FGasper

internal/verifier/mismatches.go

@@ -5,7 +5,6 @@ import (
 	"encoding/binary"
 	"fmt"
 
-	"github.com/10gen/migration-verifier/mbson"
 	"github.com/10gen/migration-verifier/option"
 	"github.com/pkg/errors"
 	"github.com/samber/lo"
@@ -140,11 +139,11 @@ func countMismatchesForTasks(
 	return matched, totalRV.AsInt64() - matched, nil
 }
 
-func countMismatchesForGeneration(
+func countRechecksForGeneration(
 	ctx context.Context,
 	metaDB *mongo.Database,
 	generation int,
-) (int64, error) {
+) (int64, int64, error) {
 	cursor, err := metaDB.Collection(verificationTasksCollection).Aggregate(
 		ctx,
 		mongo.Pipeline{
@@ -157,35 +156,51 @@ func countMismatchesForGeneration(
 				{"foreignField", "task"},
 				{"as", "mismatches"},
 			}}},
+			{{"$addFields", bson.D{
+				{"mismatches", bson.D{{"$size", "$mismatches"}}},
+			}}},
 			{{"$group", bson.D{
 				{"_id", nil},
+				{"changes", bson.D{
+					{"$sum", bson.D{
+						{"$subtract", bson.A{
+							bson.D{{"$size", "$_ids"}},
+							"$mismatches",
+						}},
+					}},
+				}},
 				{"mismatches", bson.D{
-					{"$sum", bson.D{{"$size", "$mismatches"}}},
+					{"$sum", "$mismatches"},
 				}},
 			}}},
 		},
 	)
 	if err != nil {
-		return 0, errors.Wrap(err, "sending query to count last generation’s found mismatches")
+		return 0, 0, errors.Wrap(err, "sending query to count last generation’s found mismatches")
 	}
 
 	defer cursor.Close(ctx)
 
 	if !cursor.Next(ctx) {
 		if cursor.Err() != nil {
-			return 0, errors.Wrap(err, "reading count of last generation’s found mismatches")
+			return 0, 0, errors.Wrap(err, "reading count of last generation’s found mismatches")
 		}
 
 		// This happens if there were no tasks in the queried generation.
-		return 0, nil
+		return 0, 0, nil
 	}
 
-	mmRV, err := cursor.Current.LookupErr("mismatches")
+	result := struct {
+		Mismatches int64
+		Changes    int64
+	}{}
+
+	err = cursor.Decode(&result)
 	if err != nil {
-		return 0, errors.Wrapf(err, "reading mismatches from result (%v)", cursor.Current)
+		return 0, 0, errors.Wrapf(err, "reading mismatches from result (%v)", cursor.Current)
 	}
 
-	return mbson.ToInt64(mmRV)
+	return result.Mismatches, result.Changes, nil
 }
 
 func getMismatchesForTasks(

internal/verifier/progress.go

@@ -26,7 +26,7 @@ func (verifier *Verifier) GetProgress(ctx context.Context) (Progress, error) {
 		progressTime := time.Now()
 		genElapsed := progressTime.Sub(verifier.generationStartTime)
 
-		genStats.TimeElapsed = option.Some(genElapsed.Round(10 * time.Millisecond).String())
+		genStats.TimeElapsed = option.Some(genElapsed.Round(time.Millisecond).String())
 	}
 
 	eg, egCtx := contextplus.ErrGroup(ctx)
@@ -42,7 +42,7 @@ func (verifier *Verifier) GetProgress(ctx context.Context) (Progress, error) {
 	if generation > 0 {
 		eg.Go(
 			func() error {
-				count, err := countMismatchesForGeneration(
+				mismatches, changes, err := countRechecksForGeneration(
 					egCtx,
 					verifier.metaClient.Database(verifier.metaDBName),
 					generation-1,
@@ -52,7 +52,10 @@ func (verifier *Verifier) GetProgress(ctx context.Context) (Progress, error) {
 					return errors.Wrapf(err, "counting mismatches seen during generation %d", generation-1)
 				}
 
-				genStats.PriorMismatches = option.Some(count)
+				genStats.PriorRechecks = option.Some(ProgressRechecks{
+					Changes:    changes,
+					Mismatches: mismatches,
+				})
 
 				return nil
 			},

internal/verifier/webserver.go

@@ -242,6 +242,11 @@ func (server *WebServer) writesOffEndpoint(c *gin.Context) {
 	successResponse(c)
 }
 
+type ProgressRechecks struct {
+	Mismatches int64 `json:"mismatches"`
+	Changes    int64 `json:"changes"`
+}
+
 type ProgressGenerationStats struct {
 	TimeElapsed   option.Option[string] `json:"timeElapsed"`
 	ActiveWorkers int                   `json:"activeWorkers"`
@@ -252,9 +257,9 @@ type ProgressGenerationStats struct {
 	SrcBytesCompared types.ByteCount `json:"srcBytesCompared"`
 	TotalSrcBytes    types.ByteCount `json:"totalSrcBytes,omitempty"`
 
-	PriorMismatches  option.Option[int64] `json:"priorMismatches"`
-	MismatchesFound  int64                `json:"mismatchesFound"`
-	RechecksEnqueued int64                `json:"rechecksEnqueued"`
+	PriorRechecks    option.Option[ProgressRechecks] `json:"priorRechecks"`
+	MismatchesFound  int64                           `json:"mismatchesFound"`
+	RechecksEnqueued int64                           `json:"rechecksEnqueued"`
 }
 
 type ProgressChangeStats struct {