handle msgpack the same way as json (safe defaults)

Unmarshal into object with timestamp handling.
Add test case for unmarshaling

Author: mterhar

receiver/libhoneyreceiver/internal/libhoneyevent/libhoneyevent.go

@@ -4,6 +4,7 @@
 package libhoneyevent // import "github.com/open-telemetry/opentelemetry-collector-contrib/receiver/libhoneyreceiver/internal/libhoneyevent"
 
 import (
+	"bytes"
 	"crypto/rand"
 	"encoding/binary"
 	"encoding/hex"
@@ -15,6 +16,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/vmihailenco/msgpack/v5"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/plog"
 	"go.opentelemetry.io/collector/pdata/ptrace"
@@ -87,6 +89,56 @@ func (l *LibhoneyEvent) UnmarshalJSON(j []byte) error {
 	return nil
 }
 
+// UnmarshalMsgpack overrides the unmarshall to make sure the MsgPackTimestamp is set
+func (l *LibhoneyEvent) UnmarshalMsgpack(data []byte) error {
+	type _libhoneyEvent LibhoneyEvent
+	tstr := eventtime.GetEventTimeDefaultString()
+	tzero := time.Time{}
+	tmp := _libhoneyEvent{Time: "none", MsgPackTimestamp: &tzero, Samplerate: 1}
+
+	// Use a temporary struct to avoid recursion
+	type tempEvent struct {
+		Samplerate       int            `msgpack:"samplerate"`
+		MsgPackTimestamp *time.Time     `msgpack:"time"`
+		Time             string         `msgpack:"-"` // Ignore during msgpack unmarshal
+		Data             map[string]any `msgpack:"data"`
+	}
+
+	var tmpEvent tempEvent
+	// First unmarshal into the temp struct
+	decoder := msgpack.NewDecoder(bytes.NewReader(data))
+	decoder.UseLooseInterfaceDecoding(true)
+	err := decoder.Decode(&tmpEvent)
+	if err != nil {
+		return err
+	}
+
+	// Copy fields to our tmp struct
+	tmp.Samplerate = tmpEvent.Samplerate
+	tmp.MsgPackTimestamp = tmpEvent.MsgPackTimestamp
+	tmp.Data = tmpEvent.Data
+
+	// Check if Time field exists in Data and extract it
+	if timeStr, ok := tmpEvent.Data["time"].(string); ok {
+		tmp.Time = timeStr
+	}
+
+	// Apply the same timestamp logic as JSON
+	if (tmp.MsgPackTimestamp == nil || tmp.MsgPackTimestamp.IsZero()) && tmp.Time == "none" {
+		// neither timestamp was set. give it right now.
+		tmp.Time = tstr
+		tnow := time.Now()
+		tmp.MsgPackTimestamp = &tnow
+	}
+	if tmp.MsgPackTimestamp == nil || tmp.MsgPackTimestamp.IsZero() {
+		propertime := eventtime.GetEventTime(tmp.Time)
+		tmp.MsgPackTimestamp = &propertime
+	}
+
+	*l = LibhoneyEvent(tmp)
+	return nil
+}
+
 // DebugString returns a string representation of the LibhoneyEvent
 func (l *LibhoneyEvent) DebugString() string {
 	return fmt.Sprintf("%#v", l)

receiver/libhoneyreceiver/internal/libhoneyevent/libhoneyevent_test.go

@@ -10,6 +10,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/vmihailenco/msgpack/v5"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/plog"
 	"go.opentelemetry.io/collector/pdata/ptrace"
@@ -610,3 +611,99 @@ func TestGetParentID(t *testing.T) {
 		})
 	}
 }
+
+func TestLibhoneyEvent_UnmarshalMsgpack(t *testing.T) {
+	tests := []struct {
+		name                  string
+		msgpackData           map[string]any
+		expectNonNilTimestamp bool
+		wantErr               bool
+	}{
+		{
+			name: "msgpack with nil timestamp",
+			msgpackData: map[string]any{
+				"data": map[string]any{
+					"key": "value",
+				},
+				"samplerate": 1,
+				// time field is not set (nil)
+			},
+			expectNonNilTimestamp: true,
+		},
+		{
+			name: "msgpack with time string in data",
+			msgpackData: map[string]any{
+				"data": map[string]any{
+					"key":  "value",
+					"time": "2024-01-01T00:00:00Z",
+				},
+				"samplerate": 2,
+			},
+			expectNonNilTimestamp: true,
+		},
+		{
+			name: "msgpack with timestamp field",
+			msgpackData: map[string]any{
+				"time": time.Now(),
+				"data": map[string]any{
+					"key": "value",
+				},
+				"samplerate": 3,
+			},
+			expectNonNilTimestamp: true,
+		},
+		{
+			name: "msgpack with zero timestamp",
+			msgpackData: map[string]any{
+				"time": time.Time{},
+				"data": map[string]any{
+					"key": "value",
+				},
+				"samplerate": 4,
+			},
+			expectNonNilTimestamp: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Marshal the test data to msgpack
+			msgpackBytes, err := msgpack.Marshal(tt.msgpackData)
+			require.NoError(t, err)
+
+			// Unmarshal using our custom unmarshaller
+			var event LibhoneyEvent
+			err = event.UnmarshalMsgpack(msgpackBytes)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+				return
+			}
+
+			require.NoError(t, err)
+
+			// The key assertion: MsgPackTimestamp should never be nil after unmarshalling
+			if tt.expectNonNilTimestamp {
+				assert.NotNil(t, event.MsgPackTimestamp, "MsgPackTimestamp should never be nil after UnmarshalMsgpack")
+
+				// Additional checks
+				if event.MsgPackTimestamp != nil && !event.MsgPackTimestamp.IsZero() {
+					// If we have a valid timestamp, Time string should also be set
+					assert.NotEmpty(t, event.Time, "Time string should be set when MsgPackTimestamp is valid")
+				}
+			}
+
+			// Check that data was preserved
+			assert.Equal(t, tt.msgpackData["samplerate"], event.Samplerate)
+			if data, ok := tt.msgpackData["data"].(map[string]any); ok {
+				// Remove "time" from data if it was extracted
+				delete(data, "time")
+				if len(data) > 0 {
+					for k, v := range data {
+						assert.Equal(t, v, event.Data[k])
+					}
+				}
+			}
+		})
+	}
+}

receiver/libhoneyreceiver/receiver.go

@@ -15,7 +15,6 @@ import (
 	"net/http"
 	"strings"
 	"sync"
-	"time"
 
 	"github.com/vmihailenco/msgpack/v5"
 	"go.opentelemetry.io/collector/component"
@@ -27,7 +26,6 @@ import (
 
 	"github.com/open-telemetry/opentelemetry-collector-contrib/internal/coreinternal/errorutil"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/libhoneyreceiver/encoder"
-	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/libhoneyreceiver/internal/eventtime"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/libhoneyreceiver/internal/libhoneyevent"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/libhoneyreceiver/internal/parser"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/libhoneyreceiver/internal/response"
@@ -253,6 +251,7 @@ func (r *libhoneyReceiver) handleEvent(resp http.ResponseWriter, req *http.Reque
 	libhoneyevents := make([]libhoneyevent.LibhoneyEvent, 0)
 	switch req.Header.Get("Content-Type") {
 	case "application/x-msgpack", "application/msgpack":
+		// The custom UnmarshalMsgpack will handle timestamp normalization
 		decoder := msgpack.NewDecoder(bytes.NewReader(body))
 		decoder.UseLooseInterfaceDecoding(true)
 		err = decoder.Decode(&libhoneyevents)
@@ -261,27 +260,9 @@ func (r *libhoneyReceiver) handleEvent(resp http.ResponseWriter, req *http.Reque
 			writeLibhoneyError(resp, enc, "failed to unmarshal msgpack")
 			return
 		}
-		// Post-process msgpack events to ensure timestamps are set
-		for i := range libhoneyevents {
-			if libhoneyevents[i].MsgPackTimestamp == nil {
-				if libhoneyevents[i].Time != "" {
-					// Parse the time string and set MsgPackTimestamp
-					propertime := eventtime.GetEventTime(libhoneyevents[i].Time)
-					libhoneyevents[i].MsgPackTimestamp = &propertime
-				} else {
-					// No time field, use current time
-					tnow := time.Now()
-					libhoneyevents[i].MsgPackTimestamp = &tnow
-					libhoneyevents[i].Time = eventtime.GetEventTimeDefaultString()
-				}
-			}
-		}
 		if len(libhoneyevents) > 0 {
-			if libhoneyevents[0].MsgPackTimestamp != nil {
-				r.settings.Logger.Debug("Decoding with msgpack worked", zap.Time("timestamp.first.msgpacktimestamp", *libhoneyevents[0].MsgPackTimestamp), zap.String("timestamp.first.time", libhoneyevents[0].Time))
-			} else {
-				r.settings.Logger.Debug("Decoding with msgpack worked", zap.String("timestamp.first.time", libhoneyevents[0].Time))
-			}
+			// MsgPackTimestamp is guaranteed to be non-nil after UnmarshalMsgpack
+			r.settings.Logger.Debug("Decoding with msgpack worked", zap.Time("timestamp.first.msgpacktimestamp", *libhoneyevents[0].MsgPackTimestamp), zap.String("timestamp.first.time", libhoneyevents[0].Time))
 			r.settings.Logger.Debug("event zero", zap.String("event.data", libhoneyevents[0].DebugString()))
 		}
 	case encoder.JSONContentType: