chore: add omitzero and remove custom serialization (#1197)

Author: giortzisg

interfaces.go

@@ -66,39 +66,12 @@ type Breadcrumb struct {
 	Message   string                 `json:"message,omitempty"`
 	Data      map[string]interface{} `json:"data,omitempty"`
 	Level     Level                  `json:"level,omitempty"`
-	Timestamp time.Time              `json:"timestamp"`
+	Timestamp time.Time              `json:"timestamp,omitzero"`
 }
 
 // TODO: provide constants for known breadcrumb types.
 // See https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types.
 
-// MarshalJSON converts the Breadcrumb struct to JSON.
-func (b *Breadcrumb) MarshalJSON() ([]byte, error) {
-	// We want to omit time.Time zero values, otherwise the server will try to
-	// interpret dates too far in the past. However, encoding/json doesn't
-	// support the "omitempty" option for struct types. See
-	// https://golang.org/issues/11939.
-	//
-	// We overcome the limitation and achieve what we want by shadowing fields
-	// and a few type tricks.
-
-	// breadcrumb aliases Breadcrumb to allow calling json.Marshal without an
-	// infinite loop. It preserves all fields while none of the attached
-	// methods.
-	type breadcrumb Breadcrumb
-
-	if b.Timestamp.IsZero() {
-		return json.Marshal(struct {
-			// Embed all the fields of Breadcrumb.
-			*breadcrumb
-			// Timestamp shadows the original Timestamp field and is meant to
-			// remain nil, triggering the omitempty behavior.
-			Timestamp json.RawMessage `json:"timestamp,omitempty"`
-		}{breadcrumb: (*breadcrumb)(b)})
-	}
-	return json.Marshal((*breadcrumb)(b))
-}
-
 // Logger provides a chaining API for structured logging to Sentry.
 type Logger interface {
 	// Write implements the io.Writer interface. Currently, the [sentry.Hub] is
@@ -436,7 +409,7 @@ type Event struct {
 	ServerName  string                 `json:"server_name,omitempty"`
 	Threads     []Thread               `json:"threads,omitempty"`
 	Tags        map[string]string      `json:"tags,omitempty"`
-	Timestamp   time.Time              `json:"timestamp"`
+	Timestamp   time.Time              `json:"timestamp,omitzero"`
 	Transaction string                 `json:"transaction,omitempty"`
 	User        User                   `json:"user,omitempty"`
 	Logger      string                 `json:"logger,omitempty"`
@@ -449,7 +422,7 @@ type Event struct {
 	// The fields below are only relevant for transactions.
 
 	Type            string           `json:"type,omitempty"`
-	StartTime       time.Time        `json:"start_timestamp"`
+	StartTime       time.Time        `json:"start_timestamp,omitzero"`
 	Spans           []*Span          `json:"spans,omitempty"`
 	TransactionInfo *TransactionInfo `json:"transaction_info,omitempty"`
 
@@ -561,17 +534,6 @@ func (e *Event) GetDynamicSamplingContext() map[string]string {
 
 // MarshalJSON converts the Event struct to JSON.
 func (e *Event) MarshalJSON() ([]byte, error) {
-	// We want to omit time.Time zero values, otherwise the server will try to
-	// interpret dates too far in the past. However, encoding/json doesn't
-	// support the "omitempty" option for struct types. See
-	// https://golang.org/issues/11939.
-	//
-	// We overcome the limitation and achieve what we want by shadowing fields
-	// and a few type tricks.
-	if e.Type == transactionType {
-		return e.transactionMarshalJSON()
-	}
-
 	if e.Type == checkInType {
 		return e.checkInMarshalJSON()
 	}
@@ -583,29 +545,24 @@ func (e *Event) defaultMarshalJSON() ([]byte, error) {
 	// loop. It preserves all fields while none of the attached methods.
 	type event Event
 
+	if e.Type == transactionType {
+		return json.Marshal(struct{ *event }{(*event)(e)})
+	}
 	// metrics and logs should be serialized under the same `items` json field.
 	if e.Type == logEvent.Type {
 		type logEvent struct {
 			*event
-			Items           []Log           `json:"items,omitempty"`
-			Type            json.RawMessage `json:"type,omitempty"`
-			Timestamp       json.RawMessage `json:"timestamp,omitempty"`
-			StartTime       json.RawMessage `json:"start_timestamp,omitempty"`
-			Spans           json.RawMessage `json:"spans,omitempty"`
-			TransactionInfo json.RawMessage `json:"transaction_info,omitempty"`
+			Items []Log           `json:"items,omitempty"`
+			Type  json.RawMessage `json:"type,omitempty"`
 		}
 		return json.Marshal(logEvent{event: (*event)(e), Items: e.Logs})
 	}
 
 	if e.Type == traceMetricEvent.Type {
 		type metricEvent struct {
 			*event
-			Items           []Metric        `json:"items,omitempty"`
-			Type            json.RawMessage `json:"type,omitempty"`
-			Timestamp       json.RawMessage `json:"timestamp,omitempty"`
-			StartTime       json.RawMessage `json:"start_timestamp,omitempty"`
-			Spans           json.RawMessage `json:"spans,omitempty"`
-			TransactionInfo json.RawMessage `json:"transaction_info,omitempty"`
+			Items []Metric        `json:"items,omitempty"`
+			Type  json.RawMessage `json:"type,omitempty"`
 		}
 		return json.Marshal(metricEvent{event: (*event)(e), Items: e.Metrics})
 	}
@@ -615,10 +572,6 @@ func (e *Event) defaultMarshalJSON() ([]byte, error) {
 	type errorEvent struct {
 		*event
 
-		// Timestamp shadows the original Timestamp field. It allows us to
-		// include the timestamp when non-zero and omit it otherwise.
-		Timestamp json.RawMessage `json:"timestamp,omitempty"`
-
 		// The fields below are not part of error events and only make sense to
 		// be sent for transactions. They shadow the respective fields in Event
 		// and are meant to remain nil, triggering the omitempty behavior.
@@ -630,48 +583,6 @@ func (e *Event) defaultMarshalJSON() ([]byte, error) {
 	}
 
 	x := errorEvent{event: (*event)(e)}
-	if !e.Timestamp.IsZero() {
-		b, err := e.Timestamp.MarshalJSON()
-		if err != nil {
-			return nil, err
-		}
-		x.Timestamp = b
-	}
-	return json.Marshal(x)
-}
-
-func (e *Event) transactionMarshalJSON() ([]byte, error) {
-	// event aliases Event to allow calling json.Marshal without an infinite
-	// loop. It preserves all fields while none of the attached methods.
-	type event Event
-
-	// transactionEvent is like Event with shadowed fields for customizing JSON
-	// marshaling.
-	type transactionEvent struct {
-		*event
-
-		// The fields below shadow the respective fields in Event. They allow us
-		// to include timestamps when non-zero and omit them otherwise.
-
-		StartTime json.RawMessage `json:"start_timestamp,omitempty"`
-		Timestamp json.RawMessage `json:"timestamp,omitempty"`
-	}
-
-	x := transactionEvent{event: (*event)(e)}
-	if !e.Timestamp.IsZero() {
-		b, err := e.Timestamp.MarshalJSON()
-		if err != nil {
-			return nil, err
-		}
-		x.Timestamp = b
-	}
-	if !e.StartTime.IsZero() {
-		b, err := e.StartTime.MarshalJSON()
-		if err != nil {
-			return nil, err
-		}
-		x.StartTime = b
-	}
 	return json.Marshal(x)
 }
 
@@ -748,9 +659,9 @@ type EventHint struct {
 }
 
 type Log struct {
-	Timestamp  time.Time            `json:"timestamp"`
+	Timestamp  time.Time            `json:"timestamp,omitzero"`
 	TraceID    TraceID              `json:"trace_id"`
-	SpanID     SpanID               `json:"span_id,omitempty"`
+	SpanID     SpanID               `json:"span_id,omitzero"`
 	Level      LogLevel             `json:"level"`
 	Severity   int                  `json:"severity_number,omitempty"`
 	Body       string               `json:"body"`
@@ -792,35 +703,6 @@ type Attribute struct {
 	Type  AttrType `json:"type"`
 }
 
-// MarshalJSON converts a Log to JSON that skips SpanID and timestamp when zero.
-func (l *Log) MarshalJSON() ([]byte, error) {
-	type log Log
-
-	var spanID string
-	if l.SpanID != zeroSpanID {
-		spanID = l.SpanID.String()
-	}
-
-	var ts json.RawMessage
-	if !l.Timestamp.IsZero() {
-		b, err := l.Timestamp.MarshalJSON()
-		if err != nil {
-			return nil, err
-		}
-		ts = b
-	}
-
-	return json.Marshal(struct {
-		*log
-		SpanID    string          `json:"span_id,omitempty"`
-		Timestamp json.RawMessage `json:"timestamp,omitempty"`
-	}{
-		log:       (*log)(l),
-		SpanID:    spanID,
-		Timestamp: ts,
-	})
-}
-
 type MetricType string
 
 const (
@@ -831,45 +713,16 @@ const (
 )
 
 type Metric struct {
-	Timestamp  time.Time            `json:"timestamp"`
+	Timestamp  time.Time            `json:"timestamp,omitzero"`
 	TraceID    TraceID              `json:"trace_id"`
-	SpanID     SpanID               `json:"span_id,omitempty"`
+	SpanID     SpanID               `json:"span_id,omitzero"`
 	Type       MetricType           `json:"type"`
 	Name       string               `json:"name"`
 	Value      MetricValue          `json:"value"`
 	Unit       string               `json:"unit,omitempty"`
 	Attributes map[string]Attribute `json:"attributes,omitempty"`
 }
 
-// MarshalJSON converts a Metric to JSON that skips SpanID and timestamp when zero.
-func (m *Metric) MarshalJSON() ([]byte, error) {
-	type metric Metric
-
-	var spanID string
-	if m.SpanID != zeroSpanID {
-		spanID = m.SpanID.String()
-	}
-
-	var ts json.RawMessage
-	if !m.Timestamp.IsZero() {
-		b, err := m.Timestamp.MarshalJSON()
-		if err != nil {
-			return nil, err
-		}
-		ts = b
-	}
-
-	return json.Marshal(struct {
-		*metric
-		SpanID    string          `json:"span_id,omitempty"`
-		Timestamp json.RawMessage `json:"timestamp,omitempty"`
-	}{
-		metric:    (*metric)(m),
-		SpanID:    spanID,
-		Timestamp: ts,
-	})
-}
-
 // GetCategory returns the rate limit category for metrics.
 func (m *Metric) GetCategory() ratelimit.Category {
 	return ratelimit.CategoryTraceMetric

interfaces_test.go

@@ -196,7 +196,7 @@ func TestEventMarshalJSON(t *testing.T) {
 	}
 
 	// Non-transaction event should not have fields Spans and StartTime
-	want := `{"sdk":{},"user":{},"timestamp":"1970-01-01T00:00:14Z"}`
+	want := `{"sdk":{},"timestamp":"1970-01-01T00:00:14Z","user":{}}`
 
 	if diff := cmp.Diff(want, string(got)); diff != "" {
 		t.Errorf("Event mismatch (-want +got):\n%s", diff)

internal/protocol/envelope.go

@@ -21,7 +21,7 @@ type EnvelopeHeader struct {
 
 	// SentAt is the timestamp when the event was sent from the SDK as string in RFC 3339 format.
 	// Used for clock drift correction of the event timestamp. The time zone must be UTC.
-	SentAt time.Time `json:"sent_at,omitempty"`
+	SentAt time.Time `json:"sent_at,omitzero"`
 
 	// Dsn can be used for self-authenticated envelopes.
 	// This means that the envelope has all the information necessary to be sent to sentry.
@@ -169,12 +169,6 @@ func (e *Envelope) Size() (int, error) {
 	return len(data), nil
 }
 
-// MarshalJSON converts the EnvelopeHeader to JSON.
-func (h *EnvelopeHeader) MarshalJSON() ([]byte, error) {
-	type header EnvelopeHeader
-	return json.Marshal((*header)(h))
-}
-
 // NewEnvelopeItem creates a new envelope item with the specified type and payload.
 func NewEnvelopeItem(itemType EnvelopeItemType, payload []byte) *EnvelopeItem {
 	length := len(payload)

internal/protocol/envelope_test.go

@@ -184,34 +184,3 @@ func TestEnvelope_Size(t *testing.T) {
 		t.Errorf("Size() = %d, but Serialize() length = %d", size2, len(data))
 	}
 }
-
-func TestEnvelopeHeader_MarshalJSON(t *testing.T) {
-	header := &EnvelopeHeader{
-		EventID: "12345678901234567890123456789012",
-		SentAt:  time.Date(2023, 1, 1, 12, 0, 0, 0, time.UTC),
-		Dsn:     "https://public@example.com/1",
-		Trace:   map[string]string{"trace_id": "abc123"},
-	}
-
-	data, err := header.MarshalJSON()
-	if err != nil {
-		t.Errorf("MarshalJSON() error = %v", err)
-	}
-
-	var result map[string]interface{}
-	if err := json.Unmarshal(data, &result); err != nil {
-		t.Errorf("Marshaled JSON is invalid: %v", err)
-	}
-
-	if result["event_id"] != header.EventID {
-		t.Errorf("Expected event_id %s, got %v", header.EventID, result["event_id"])
-	}
-
-	if result["dsn"] != header.Dsn {
-		t.Errorf("Expected dsn %s, got %v", header.Dsn, result["dsn"])
-	}
-
-	if bytes.Contains(data, []byte("\n")) {
-		t.Error("Marshaled JSON contains newlines")
-	}
-}

propagation_context.go

@@ -2,31 +2,15 @@ package sentry
 
 import (
 	"crypto/rand"
-	"encoding/json"
 )
 
 type PropagationContext struct {
 	TraceID                TraceID                `json:"trace_id"`
 	SpanID                 SpanID                 `json:"span_id"`
-	ParentSpanID           SpanID                 `json:"parent_span_id"`
+	ParentSpanID           SpanID                 `json:"parent_span_id,omitzero"`
 	DynamicSamplingContext DynamicSamplingContext `json:"-"`
 }
 
-func (p PropagationContext) MarshalJSON() ([]byte, error) {
-	type propagationContext PropagationContext
-	var parentSpanID string
-	if p.ParentSpanID != zeroSpanID {
-		parentSpanID = p.ParentSpanID.String()
-	}
-	return json.Marshal(struct {
-		*propagationContext
-		ParentSpanID string `json:"parent_span_id,omitempty"`
-	}{
-		propagationContext: (*propagationContext)(&p),
-		ParentSpanID:       parentSpanID,
-	})
-}
-
 func (p PropagationContext) Map() map[string]interface{} {
 	m := map[string]interface{}{
 		"trace_id": p.TraceID,

testdata/error_event.golden

@@ -38,9 +38,9 @@
         ]
     },
     "server_name": "myhost",
+    "timestamp": "1970-01-01T00:00:05Z",
     "transaction": "mytransaction",
     "user": {
         "id": "foo"
-    },
-    "timestamp": "1970-01-01T00:00:05Z"
+    }
 }

testdata/json/event/000.json

@@ -1,6 +1,6 @@
 {
   "message": "test",
   "sdk": {},
-  "user": {},
-  "timestamp": "2009-11-10T23:00:00Z"
+  "timestamp": "2009-11-10T23:00:00Z",
+  "user": {}
 }

testdata/json/event/001.json

@@ -1,6 +1,6 @@
 {
   "message": "test",
   "sdk": {},
-  "user": {},
-  "timestamp": "2009-11-10T21:00:00-02:00"
+  "timestamp": "2009-11-10T21:00:00-02:00",
+  "user": {}
 }