[receiver/fluentforward] unexport structs (#40108)

<!--Ex. Fixing a bug - Describe the bug and how this fixes the issue.
Ex. Adding a feature - Explain what this achieves.-->
#### Description
Unexport all structs in fluentforward receiver. They have no reason to
be exposed as API.

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: atoulme

.chloggen/unexport_fluentforward.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: breaking
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: fluentforwardreceiver
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Unexport all structs in fluentforward receiver.
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [40108]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [api]

receiver/fluentforwardreceiver/collector.go

@@ -14,20 +14,20 @@ import (
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/fluentforwardreceiver/internal/metadata"
 )
 
-// Collector acts as an aggregator of LogRecords so that we don't have to
+// collector acts as an aggregator of LogRecords so that we don't have to
 // generate as many plog.Logs instances...we can pre-batch the LogRecord
 // instances from several Forward events into one to hopefully reduce
 // allocations and GC overhead.
-type Collector struct {
+type collector struct {
 	nextConsumer     consumer.Logs
-	eventCh          <-chan Event
+	eventCh          <-chan event
 	logger           *zap.Logger
 	obsrecv          *receiverhelper.ObsReport
 	telemetryBuilder *metadata.TelemetryBuilder
 }
 
-func newCollector(eventCh <-chan Event, next consumer.Logs, logger *zap.Logger, obsrecv *receiverhelper.ObsReport, telemetryBuilder *metadata.TelemetryBuilder) *Collector {
-	return &Collector{
+func newCollector(eventCh <-chan event, next consumer.Logs, logger *zap.Logger, obsrecv *receiverhelper.ObsReport, telemetryBuilder *metadata.TelemetryBuilder) *collector {
+	return &collector{
 		nextConsumer:     next,
 		eventCh:          eventCh,
 		logger:           logger,
@@ -36,11 +36,11 @@ func newCollector(eventCh <-chan Event, next consumer.Logs, logger *zap.Logger,
 	}
 }
 
-func (c *Collector) Start(ctx context.Context) {
+func (c *collector) Start(ctx context.Context) {
 	go c.processEvents(ctx)
 }
 
-func (c *Collector) processEvents(ctx context.Context) {
+func (c *collector) processEvents(ctx context.Context) {
 	for {
 		select {
 		case <-ctx.Done():
@@ -64,7 +64,7 @@ func (c *Collector) processEvents(ctx context.Context) {
 	}
 }
 
-func (c *Collector) fillBufferUntilChanEmpty(dest plog.LogRecordSlice) {
+func (c *collector) fillBufferUntilChanEmpty(dest plog.LogRecordSlice) {
 	for {
 		select {
 		case e := <-c.eventCh:

receiver/fluentforwardreceiver/conversion.go

@@ -22,49 +22,49 @@ const tagAttributeKey = "fluent.tag"
 // https://github.com/fluent/fluentd/wiki/Forward-Protocol-Specification-v1,
 // which describes the fields in much greater detail.
 
-type Event interface {
+type event interface {
 	DecodeMsg(dc *msgp.Reader) error
 	LogRecords() plog.LogRecordSlice
 	Chunk() string
 	Compressed() string
 }
 
-type OptionsMap map[string]any
+type optionsMap map[string]any
 
 // Chunk returns the `chunk` option or blank string if it was not set.
-func (om OptionsMap) Chunk() string {
+func (om optionsMap) Chunk() string {
 	c, _ := om["chunk"].(string)
 	return c
 }
 
-func (om OptionsMap) Compressed() string {
+func (om optionsMap) Compressed() string {
 	compressed, _ := om["compressed"].(string)
 	return compressed
 }
 
-type EventMode int
+type eventMode int
 
-type Peeker interface {
+type peeker interface {
 	Peek(n int) ([]byte, error)
 }
 
-// Values for enum EventMode.
+// Values for enum eventMode.
 const (
-	UnknownMode EventMode = iota
-	MessageMode
-	ForwardMode
-	PackedForwardMode
+	unknownMode eventMode = iota
+	messageMode
+	forwardMode
+	packedForwardMode
 )
 
-func (em EventMode) String() string {
+func (em eventMode) String() string {
 	switch em {
-	case UnknownMode:
+	case unknownMode:
 		return "unknown"
-	case MessageMode:
+	case messageMode:
 		return "message"
-	case ForwardMode:
+	case forwardMode:
 		return "forward"
-	case PackedForwardMode:
+	case packedForwardMode:
 		return "packedforward"
 	default:
 		panic("programmer bug")
@@ -179,16 +179,16 @@ func parseRecordToLogRecord(dc *msgp.Reader, lr plog.LogRecord) error {
 	return nil
 }
 
-type MessageEventLogRecord struct {
+type messageEventLogRecord struct {
 	plog.LogRecordSlice
-	OptionsMap
+	optionsMap
 }
 
-func (melr *MessageEventLogRecord) LogRecords() plog.LogRecordSlice {
+func (melr *messageEventLogRecord) LogRecords() plog.LogRecordSlice {
 	return melr.LogRecordSlice
 }
 
-func (melr *MessageEventLogRecord) DecodeMsg(dc *msgp.Reader) error {
+func (melr *messageEventLogRecord) DecodeMsg(dc *msgp.Reader) error {
 	melr.LogRecordSlice = plog.NewLogRecordSlice()
 	var arrLen uint32
 	var err error
@@ -215,19 +215,19 @@ func (melr *MessageEventLogRecord) DecodeMsg(dc *msgp.Reader) error {
 	}
 
 	if arrLen == 4 {
-		melr.OptionsMap, err = parseOptions(dc)
+		melr.optionsMap, err = parseOptions(dc)
 		return err
 	}
 	return nil
 }
 
-func parseOptions(dc *msgp.Reader) (OptionsMap, error) {
+func parseOptions(dc *msgp.Reader) (optionsMap, error) {
 	var optionLen uint32
 	optionLen, err := dc.ReadMapHeader()
 	if err != nil {
 		return nil, msgp.WrapError(err, "Option")
 	}
-	out := make(OptionsMap, optionLen)
+	out := make(optionsMap, optionLen)
 
 	for optionLen > 0 {
 		optionLen--
@@ -244,16 +244,16 @@ func parseOptions(dc *msgp.Reader) (OptionsMap, error) {
 	return out, nil
 }
 
-type ForwardEventLogRecords struct {
+type forwardEventLogRecords struct {
 	plog.LogRecordSlice
-	OptionsMap
+	optionsMap
 }
 
-func (fe *ForwardEventLogRecords) LogRecords() plog.LogRecordSlice {
+func (fe *forwardEventLogRecords) LogRecords() plog.LogRecordSlice {
 	return fe.LogRecordSlice
 }
 
-func (fe *ForwardEventLogRecords) DecodeMsg(dc *msgp.Reader) error {
+func (fe *forwardEventLogRecords) DecodeMsg(dc *msgp.Reader) error {
 	fe.LogRecordSlice = plog.NewLogRecordSlice()
 
 	arrLen, err := dc.ReadArrayHeader()
@@ -286,7 +286,7 @@ func (fe *ForwardEventLogRecords) DecodeMsg(dc *msgp.Reader) error {
 	}
 
 	if arrLen == 3 {
-		fe.OptionsMap, err = parseOptions(dc)
+		fe.optionsMap, err = parseOptions(dc)
 		return err
 	}
 
@@ -304,18 +304,18 @@ func parseEntryToLogRecord(dc *msgp.Reader, lr plog.LogRecord) error {
 	return parseRecordToLogRecord(dc, lr)
 }
 
-type PackedForwardEventLogRecords struct {
+type packedForwardEventLogRecords struct {
 	plog.LogRecordSlice
-	OptionsMap
+	optionsMap
 }
 
-func (pfe *PackedForwardEventLogRecords) LogRecords() plog.LogRecordSlice {
+func (pfe *packedForwardEventLogRecords) LogRecords() plog.LogRecordSlice {
 	return pfe.LogRecordSlice
 }
 
 // DecodeMsg implements msgp.Decodable.  This was originally code generated but
 // then manually copied here in order to handle the optional Options field.
-func (pfe *PackedForwardEventLogRecords) DecodeMsg(dc *msgp.Reader) error {
+func (pfe *packedForwardEventLogRecords) DecodeMsg(dc *msgp.Reader) error {
 	pfe.LogRecordSlice = plog.NewLogRecordSlice()
 
 	arrLen, err := dc.ReadArrayHeader()
@@ -361,7 +361,7 @@ func (pfe *PackedForwardEventLogRecords) DecodeMsg(dc *msgp.Reader) error {
 	}
 
 	if arrLen == 3 {
-		pfe.OptionsMap, err = parseOptions(dc)
+		pfe.optionsMap, err = parseOptions(dc)
 		if err != nil {
 			return err
 		}
@@ -375,7 +375,7 @@ func (pfe *PackedForwardEventLogRecords) DecodeMsg(dc *msgp.Reader) error {
 	return nil
 }
 
-func (pfe *PackedForwardEventLogRecords) parseEntries(entriesRaw []byte, isGzipped bool, tag string) error {
+func (pfe *packedForwardEventLogRecords) parseEntries(entriesRaw []byte, isGzipped bool, tag string) error {
 	var reader io.Reader
 	reader = bytes.NewReader(entriesRaw)
 

receiver/fluentforwardreceiver/conversion_test.go

@@ -19,12 +19,12 @@ func TestMessageEventConversion(t *testing.T) {
 	eventBytes := parseHexDump("testdata/message-event")
 	reader := msgp.NewReader(bytes.NewReader(eventBytes))
 
-	var event MessageEventLogRecord
+	var event messageEventLogRecord
 	err := event.DecodeMsg(reader)
 	require.NoError(t, err)
 
 	expectedLog := logConstructor(
-		Log{
+		log{
 			Timestamp: 1593031012000000000,
 			Body:      pcommon.NewValueStr("..."),
 			Attributes: map[string]any{
@@ -84,14 +84,14 @@ func TestAttributeTypeConversion(t *testing.T) {
 
 	reader := msgp.NewReader(bytes.NewReader(b))
 
-	var event MessageEventLogRecord
+	var event messageEventLogRecord
 	err = event.DecodeMsg(reader)
 	require.NoError(t, err)
 
 	le := event.LogRecords().At(0)
 
 	require.NoError(t, plogtest.CompareLogRecord(logConstructor(
-		Log{
+		log{
 			Timestamp: 5000000000000,
 			Body:      pcommon.NewValueEmpty(),
 			Attributes: map[string]any{
@@ -118,12 +118,12 @@ func TestAttributeTypeConversion(t *testing.T) {
 }
 
 func TestEventMode(t *testing.T) {
-	require.Equal(t, "unknown", UnknownMode.String())
-	require.Equal(t, "message", MessageMode.String())
-	require.Equal(t, "forward", ForwardMode.String())
-	require.Equal(t, "packedforward", PackedForwardMode.String())
+	require.Equal(t, "unknown", unknownMode.String())
+	require.Equal(t, "message", messageMode.String())
+	require.Equal(t, "forward", forwardMode.String())
+	require.Equal(t, "packedforward", packedForwardMode.String())
 
-	const TestMode EventMode = 6
+	const TestMode eventMode = 6
 	require.Panics(t, func() { _ = TestMode.String() })
 }
 
@@ -146,7 +146,7 @@ func TestMessageEventConversionWithErrors(t *testing.T) {
 		t.Run(fmt.Sprintf("EOF at byte %d", i), func(t *testing.T) {
 			reader := msgp.NewReader(bytes.NewReader(b[:i]))
 
-			var event MessageEventLogRecord
+			var event messageEventLogRecord
 			err := event.DecodeMsg(reader)
 			require.Error(t, err)
 		})
@@ -160,7 +160,7 @@ func TestForwardEventConversionWithErrors(t *testing.T) {
 		t.Run(fmt.Sprintf("EOF at byte %d", i), func(t *testing.T) {
 			reader := msgp.NewReader(bytes.NewReader(b[:i]))
 
-			var event ForwardEventLogRecords
+			var event forwardEventLogRecords
 			err := event.DecodeMsg(reader)
 			require.Error(t, err)
 		})
@@ -174,7 +174,7 @@ func TestPackedForwardEventConversionWithErrors(t *testing.T) {
 		t.Run(fmt.Sprintf("EOF at byte %d", i), func(t *testing.T) {
 			reader := msgp.NewReader(bytes.NewReader(b[:i]))
 
-			var event PackedForwardEventLogRecords
+			var event packedForwardEventLogRecords
 			err := event.DecodeMsg(reader)
 			require.Error(t, err)
 		})
@@ -186,7 +186,7 @@ func TestPackedForwardEventConversionWithErrors(t *testing.T) {
 		in[0x71] = 0xff
 		reader := msgp.NewReader(bytes.NewReader(in))
 
-		var event PackedForwardEventLogRecords
+		var event packedForwardEventLogRecords
 		err := event.DecodeMsg(reader)
 		require.ErrorContains(t, err, "gzip")
 		fmt.Println(err.Error())
@@ -219,7 +219,7 @@ func TestBodyConversion(t *testing.T) {
 
 	reader := msgp.NewReader(bytes.NewReader(b))
 
-	var event MessageEventLogRecord
+	var event messageEventLogRecord
 	err = event.DecodeMsg(reader)
 	require.NoError(t, err)
 
@@ -236,7 +236,7 @@ func TestBodyConversion(t *testing.T) {
 	cv.PutInt("d", 24)
 
 	require.NoError(t, plogtest.CompareLogRecord(logConstructor(
-		Log{
+		log{
 			Timestamp: 5000000000000,
 			Body:      body,
 			Attributes: map[string]any{

receiver/fluentforwardreceiver/receiver.go

@@ -22,7 +22,7 @@ import (
 const eventChannelLength = 100
 
 type fluentReceiver struct {
-	collector *Collector
+	collector *collector
 	listener  net.Listener
 	conf      *Config
 	logger    *zap.Logger
@@ -45,7 +45,7 @@ func newFluentReceiver(set receiver.Settings, conf *Config, next consumer.Logs)
 		return nil, err
 	}
 
-	eventCh := make(chan Event, eventChannelLength)
+	eventCh := make(chan event, eventChannelLength)
 	collector := newCollector(eventCh, next, set.Logger, obsrecv, telemetryBuilder)
 
 	server := newServer(eventCh, set.Logger, telemetryBuilder)