tool: update compaction summary tool

Author: xxmplus

compaction.go

@@ -154,6 +154,9 @@ const (
 	compactionKindRewrite
 	compactionKindIngestedFlushable
 	compactionKindBlobFileRewrite
+	// compactionKindVirtualRewrite must be the last compactionKind.
+	// If a new kind has to be added after VirtualRewrite,
+	// update AllCompactionKindStrings() accordingly.
 	compactionKindVirtualRewrite
 )
 
@@ -196,6 +199,20 @@ func (k compactionKind) compactingOrFlushing() string {
 	return "compacting"
 }
 
+// AllCompactionKindStrings returns all compaction kind string representations
+// for testing purposes. Used by tool/logs/compaction_test.go to verify the
+// compaction summary tool stays in sync with new compaction types.
+//
+// NOTE: This function iterates up to compactionKindVirtualRewrite. If a new
+// compactionKind is added after VirtualRewrite, update this function accordingly.
+func AllCompactionKindStrings() map[string]bool {
+	kinds := make(map[string]bool)
+	for k := compactionKindDefault; k <= compactionKindVirtualRewrite; k++ {
+		kinds[k.String()] = true
+	}
+	return kinds
+}
+
 type compaction interface {
 	AddInProgressLocked(*DB)
 	BeganAt() time.Time

tool/logs/compaction.go

@@ -48,6 +48,12 @@ var (
 		table.Div(),
 		table.Int("virt", 4, table.AlignRight, func(r compactionTableRow) int { return r.Virtual }),
 		table.Div(),
+		table.Int("copy", 4, table.AlignRight, func(r compactionTableRow) int { return r.Copy }),
+		table.Div(),
+		table.Int("tomb", 4, table.AlignRight, func(r compactionTableRow) int { return r.Tombstone }),
+		table.Div(),
+		table.Int("rwrt", 4, table.AlignRight, func(r compactionTableRow) int { return r.Rewrite }),
+		table.Div(),
 		table.Int("cnt", 3, table.AlignRight, func(r compactionTableRow) int { return r.Count }),
 		table.Div(),
 		table.Bytes("in(B)", 5, table.AlignRight, func(r compactionTableRow) uint64 { return r.BytesIn }),
@@ -106,6 +112,9 @@ type compactionTableRow struct {
 	Delete     int
 	Blob       int
 	Virtual    int
+	Copy       int
+	Tombstone  int
+	Rewrite    int
 	Count      int
 	BytesIn    uint64
 	BytesOut   uint64
@@ -304,9 +313,12 @@ const (
 	compactionTypeDefault compactionType = iota
 	compactionTypeFlush
 	compactionTypeMove
+	compactionTypeCopy
 	compactionTypeDeleteOnly
 	compactionTypeElisionOnly
 	compactionTypeRead
+	compactionTypeTombstoneDensity
+	compactionTypeRewrite
 	compactionTypeBlobRewrite
 	compactionTypeVirtualRewrite
 )
@@ -318,12 +330,18 @@ func (c compactionType) String() string {
 		return "default"
 	case compactionTypeMove:
 		return "move"
+	case compactionTypeCopy:
+		return "copy"
 	case compactionTypeDeleteOnly:
 		return "delete-only"
 	case compactionTypeElisionOnly:
 		return "elision-only"
 	case compactionTypeRead:
 		return "read"
+	case compactionTypeTombstoneDensity:
+		return "tombstone-density"
+	case compactionTypeRewrite:
+		return "rewrite"
 	case compactionTypeBlobRewrite:
 		return "blob-rewrite"
 	case compactionTypeVirtualRewrite:
@@ -341,12 +359,18 @@ func parseCompactionType(s string) (t compactionType, err error) {
 		t = compactionTypeDefault
 	case "move":
 		t = compactionTypeMove
+	case "copy":
+		t = compactionTypeCopy
 	case "delete-only":
 		t = compactionTypeDeleteOnly
 	case "elision-only":
 		t = compactionTypeElisionOnly
 	case "read":
 		t = compactionTypeRead
+	case "tombstone-density":
+		t = compactionTypeTombstoneDensity
+	case "rewrite":
+		t = compactionTypeRewrite
 	case "blob-rewrite":
 		t = compactionTypeBlobRewrite
 	case "virtual-sst-rewrite":
@@ -794,7 +818,7 @@ func (s windowSummary) String() string {
 	// Print compactions statistics.
 	if len(s.compactionCounts) > 0 {
 		var compactionRows []compactionTableRow
-		var totalDef, totalMove, totalElision, totalDel, totalBlob, totalVirtual int
+		var totalDef, totalMove, totalElision, totalDel, totalBlob, totalVirtual, totalCopy, totalTombstone, totalRewrite int
 		var totalBytesIn, totalBytesOut, totalBytesMoved, totalBytesDel uint64
 		var totalTime time.Duration
 
@@ -805,7 +829,10 @@ func (s windowSummary) String() string {
 			del := p.counts[compactionTypeDeleteOnly]
 			blob := p.counts[compactionTypeBlobRewrite]
 			virtual := p.counts[compactionTypeVirtualRewrite]
-			total := def + move + elision + del + blob + virtual
+			copy := p.counts[compactionTypeCopy]
+			tombstone := p.counts[compactionTypeTombstoneDensity]
+			rewrite := p.counts[compactionTypeRewrite]
+			total := def + move + elision + del + blob + virtual + copy + tombstone + rewrite
 
 			compactionRows = append(compactionRows, compactionTableRow{
 				Kind:       "compact",
@@ -817,6 +844,9 @@ func (s windowSummary) String() string {
 				Delete:     del,
 				Blob:       blob,
 				Virtual:    virtual,
+				Copy:       copy,
+				Tombstone:  tombstone,
+				Rewrite:    rewrite,
 				Count:      total,
 				BytesIn:    p.bytesIn,
 				BytesOut:   p.bytesOut,
@@ -831,6 +861,9 @@ func (s windowSummary) String() string {
 			totalDel += del
 			totalBlob += blob
 			totalVirtual += virtual
+			totalCopy += copy
+			totalTombstone += tombstone
+			totalRewrite += rewrite
 			totalBytesIn += p.bytesIn
 			totalBytesOut += p.bytesOut
 			totalBytesMoved += p.bytesMoved
@@ -848,6 +881,9 @@ func (s windowSummary) String() string {
 			Delete:     totalDel,
 			Blob:       totalBlob,
 			Virtual:    totalVirtual,
+			Copy:       totalCopy,
+			Tombstone:  totalTombstone,
+			Rewrite:    totalRewrite,
 			Count:      s.eventCount,
 			BytesIn:    totalBytesIn,
 			BytesOut:   totalBytesOut,

tool/logs/compaction_test.go

@@ -16,6 +16,7 @@ import (
 
 	"github.com/cockroachdb/datadriven"
 	"github.com/cockroachdb/errors"
+	"github.com/cockroachdb/pebble"
 	"github.com/stretchr/testify/require"
 )
 
@@ -465,3 +466,66 @@ func TestParseInputBytes(t *testing.T) {
 		})
 	}
 }
+
+// TestCompactionKindToolSupport verifies that the tool's compactionType enum
+// stays in sync with the main compactionKind enum in compaction.go.
+// This test will fail if a new compaction type is added to compaction.go
+// but not to this tool, preventing the tool from becoming out of date.
+func TestCompactionKindToolSupport(t *testing.T) {
+	// Get all compaction kinds from compaction.go via the helper function
+	allKinds := pebble.AllCompactionKindStrings()
+
+	// These kinds use flush logging format, not compaction logging format.
+	// They are handled separately and should NOT be in the compactionType enum.
+	flushLoggedKinds := map[string]string{
+		"flush":              "logged via FlushInfo, not CompactionInfo",
+		"ingested-flushable": "logged as 'flushed N ingested flushables' via FlushInfo (see parseIngestDuringFlush)",
+	}
+
+	var missingTypes []string
+	handledCount := 0
+
+	// Verify each non-flush kind is supported by the tool
+	for kindStr := range allKinds {
+		if reason, excluded := flushLoggedKinds[kindStr]; excluded {
+			t.Logf("Skipping %q: %s", kindStr, reason)
+			continue
+		}
+
+		// Special case: blob-file-rewrite logs as "blob-rewrite" in practice
+		testStr := kindStr
+		if kindStr == "blob-file-rewrite" {
+			testStr = "blob-rewrite"
+		}
+
+		_, err := parseCompactionType(testStr)
+		if err != nil {
+			missingTypes = append(missingTypes, kindStr)
+			t.Errorf("SYNC ERROR: compaction kind %q from compaction.go is not supported by tool/logs/compaction.go", kindStr)
+		} else {
+			handledCount++
+		}
+	}
+
+	if len(missingTypes) > 0 {
+		t.Errorf("\n"+
+			"═══════════════════════════════════════════════════════════════════════════\n"+
+			"  COMPACTION TOOL OUT OF SYNC\n"+
+			"═══════════════════════════════════════════════════════════════════════════\n"+
+			"\n"+
+			"A new compaction type was added to compaction.go but the compaction summary\n"+
+			"tool (tool/logs/compaction.go) was not updated.\n"+
+			"\n"+
+			"Missing types: %v\n"+
+			"═══════════════════════════════════════════════════════════════════════════\n",
+			missingTypes)
+	}
+
+	// Verify we're handling the expected number of types
+	expectedHandled := len(allKinds) - len(flushLoggedKinds)
+	if handledCount != expectedHandled {
+		t.Errorf("Expected to handle %d compaction types but only handle %d", expectedHandled, handledCount)
+	} else {
+		t.Logf("Successfully verified %d compaction types are supported", handledCount)
+	}
+}