[chore] Fix small nits in persistent queue metadata proto (#13125)

Signed-off-by: Bogdan Drutu <[email protected]>

Author: bogdandrutu

exporter/exporterhelper/internal/queuebatch/internal/persistentqueue/meta.pb.go

@@ -4,20 +4,27 @@ package opentelemetry.collector.exporter.exporterhelper.internal.queuebatch.inte
 
 option go_package = "go.opentelemetry.io/collector/exporter/exporterhelper/internal/queuebatch/internal/persistentqueue";
 
+// Sizer type configuration
+enum SizerType {
+  REQUESTS = 0;
+  ITEMS = 1;
+  BYTES = 2;
+}
+
 // QueueMetadata holds all persistent metadata for the queue.
 message QueueMetadata{
-  // Sizer type configuration (bytes=0, items=1, requests=2)
-  int32 sizer_type_value = 1; 
+  // Sizer type configuration.
+  SizerType sizer_type = 1;
 
-  // Index of the next item to be read from the queue  
-  uint64 read_index = 2;
+  // Current total size of the queue (in bytes, items, or requests).
+  sfixed64 queue_size = 2;
 
-  // Index where the next item will be written to the queue
-  uint64 write_index = 3;
+  // Index of the next item to be read from the queue.
+  fixed64 read_index = 3;
 
-  // Current total size of the queue (in bytes, items, or requests)
-  sfixed64 queue_size = 4;
+  // Index where the next item will be written to the queue.
+  fixed64 write_index = 4;
 
-  // List of item indices currently being processed by consumers
+  // List of item indices currently being processed by consumers.
   repeated fixed64 currently_dispatched_items = 5;
 }

exporter/exporterhelper/internal/queuebatch/internal/persistentqueue/meta.proto

@@ -9,36 +9,29 @@ import (
 	"go.opentelemetry.io/collector/exporter/exporterhelper/internal/request"
 )
 
-// Numeric constants for protobuf serialization
-const (
-	SizerTypeBytes    int32 = iota // 0
-	SizerTypeItems                 // 1
-	SizerTypeRequests              // 2
-)
-
 // SizerTypeToProto converts SizerType to int32 for protobuf serialization
-func SizerTypeToProto(sizerType request.SizerType) (int32, error) {
+func SizerTypeToProto(sizerType request.SizerType) (SizerType, error) {
 	switch sizerType {
-	case request.SizerTypeBytes:
-		return SizerTypeBytes, nil
-	case request.SizerTypeItems:
-		return SizerTypeItems, nil
 	case request.SizerTypeRequests:
-		return SizerTypeRequests, nil
+		return SizerType_REQUESTS, nil
+	case request.SizerTypeItems:
+		return SizerType_ITEMS, nil
+	case request.SizerTypeBytes:
+		return SizerType_BYTES, nil
 	default:
 		return -1, fmt.Errorf("invalid sizer type: %v", sizerType)
 	}
 }
 
 // SizerTypeFromProto creates SizerType from int32 representation
-func SizerTypeFromProto(value int32) (request.SizerType, error) {
+func SizerTypeFromProto(value SizerType) (request.SizerType, error) {
 	switch value {
-	case SizerTypeBytes:
-		return request.SizerTypeBytes, nil
-	case SizerTypeItems:
-		return request.SizerTypeItems, nil
-	case SizerTypeRequests:
+	case SizerType_REQUESTS:
 		return request.SizerTypeRequests, nil
+	case SizerType_ITEMS:
+		return request.SizerTypeItems, nil
+	case SizerType_BYTES:
+		return request.SizerTypeBytes, nil
 	default:
 		return request.SizerType{}, fmt.Errorf("invalid sizer type value: %d", value)
 	}

exporter/exporterhelper/internal/queuebatch/internal/persistentqueue/sizer_conversion.go

@@ -16,23 +16,23 @@ func TestSizerTypeToProto(t *testing.T) {
 	tests := []struct {
 		name           string
 		sizerType      request.SizerType
-		protoSizerType int32
+		protoSizerType SizerType
 		wantErr        bool
 	}{
 		{
 			name:           "requests",
 			sizerType:      request.SizerTypeRequests,
-			protoSizerType: SizerTypeRequests,
+			protoSizerType: SizerType_REQUESTS,
 		},
 		{
 			name:           "items",
 			sizerType:      request.SizerTypeItems,
-			protoSizerType: SizerTypeItems,
+			protoSizerType: SizerType_ITEMS,
 		},
 		{
 			name:           "bytes",
 			sizerType:      request.SizerTypeBytes,
-			protoSizerType: SizerTypeBytes,
+			protoSizerType: SizerType_BYTES,
 		},
 		{
 			name:           "invalid",
@@ -58,23 +58,23 @@ func TestSizerTypeFromProto(t *testing.T) {
 	tests := []struct {
 		name           string
 		sizerType      request.SizerType
-		protoSizerType int32
+		protoSizerType SizerType
 		wantErr        bool
 	}{
 		{
 			name:           "requests",
 			sizerType:      request.SizerTypeRequests,
-			protoSizerType: SizerTypeRequests,
+			protoSizerType: SizerType_REQUESTS,
 		},
 		{
 			name:           "items",
 			sizerType:      request.SizerTypeItems,
-			protoSizerType: SizerTypeItems,
+			protoSizerType: SizerType_ITEMS,
 		},
 		{
 			name:           "bytes",
 			sizerType:      request.SizerTypeBytes,
-			protoSizerType: SizerTypeBytes,
+			protoSizerType: SizerType_BYTES,
 		},
 		{
 			name:           "invalid",
@@ -95,3 +95,27 @@ func TestSizerTypeFromProto(t *testing.T) {
 		})
 	}
 }
+
+func TestSizerTypeRoundTrip(t *testing.T) {
+	// Test that converting to int32 and back results in the same value
+	sizerTypes := []request.SizerType{
+		request.SizerTypeBytes,
+		request.SizerTypeItems,
+		request.SizerTypeRequests,
+	}
+
+	for _, originalType := range sizerTypes {
+		t.Run(originalType.String(), func(t *testing.T) {
+			// Convert to int32
+			protoVal, err := SizerTypeToProto(originalType)
+			require.NoError(t, err)
+
+			// Convert back to SizerType
+			convertedType, err := SizerTypeFromProto(protoVal)
+			require.NoError(t, err)
+
+			// Should be the same as original
+			assert.Equal(t, originalType, convertedType)
+		})
+	}
+}

exporter/exporterhelper/internal/queuebatch/internal/persistentqueue/sizer_conversion_test.go

@@ -50,6 +50,10 @@ func (s *SizerType) MarshalText() ([]byte, error) {
 	return []byte(s.val), nil
 }
 
+func (s *SizerType) String() string {
+	return s.val
+}
+
 // Sizer is an interface that returns the size of the given element.
 type Sizer[T any] interface {
 	Sizeof(T) int64