internal/event: include context cancel cause in event

The context cancel cause can be a great way to understand
why a context was canceled.

Author: johanbrandhorst

internal/event/context.go

@@ -196,7 +196,7 @@ func WriteError(ctx context.Context, caller Op, e error, opt ...Option) {
 			return
 		}
 	}
-	ev, err := newError(caller, e, opt...)
+	ev, err := newError(ctx, caller, e, opt...)
 	if err != nil {
 		eventer.logger.Error(fmt.Sprintf("%s: %v", op, err))
 		eventer.logger.Error(fmt.Sprintf("%s: unable to create new error to write error: %v", op, e))

internal/event/event_error.go

@@ -4,6 +4,7 @@
 package event
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"reflect"
@@ -13,16 +14,17 @@ import (
 const errorVersion = "v0.1"
 
 type err struct {
-	Error       string         `json:"error"`
-	ErrorFields error          `json:"error_fields"`
-	Id          Id             `json:"id,omitempty"`
-	Version     string         `json:"version"`
-	Op          Op             `json:"op,omitempty"`
-	RequestInfo *RequestInfo   `json:"request_info,omitempty"`
-	Info        map[string]any `json:"info,omitempty"`
+	Error        string         `json:"error"`
+	ErrorFields  error          `json:"error_fields"`
+	Id           Id             `json:"id,omitempty"`
+	Version      string         `json:"version"`
+	Op           Op             `json:"op,omitempty"`
+	RequestInfo  *RequestInfo   `json:"request_info,omitempty"`
+	Info         map[string]any `json:"info,omitempty"`
+	ContextCause error          `json:"cause,omitempty"`
 }
 
-func newError(fromOperation Op, e error, opt ...Option) (*err, error) {
+func newError(ctx context.Context, fromOperation Op, e error, opt ...Option) (*err, error) {
 	const op = "event.newError"
 	if fromOperation == "" {
 		return nil, fmt.Errorf("%s: missing operation: %w", op, ErrInvalidParameter)
@@ -53,6 +55,9 @@ func newError(fromOperation Op, e error, opt ...Option) (*err, error) {
 		Error:       e.Error(),
 		ErrorFields: e,
 	}
+	if ctx != nil {
+		newErr.ContextCause = context.Cause(ctx)
+	}
 	if err := newErr.validate(); err != nil {
 		return nil, fmt.Errorf("%s: %w", op, err)
 	}

internal/event/event_error_test.go

@@ -4,6 +4,9 @@
 package event
 
 import (
+	"cmp"
+	"context"
+	"errors"
 	"fmt"
 	"testing"
 
@@ -14,12 +17,16 @@ import (
 
 func Test_newError(t *testing.T) {
 	t.Parallel()
+	ctx := context.Background()
+	canceledCtx, cancel := context.WithCancelCause(ctx)
+	cancel(errors.New("test cancel"))
 
 	tests := []struct {
 		name            string
 		fromOp          Op
 		e               error
 		opts            []Option
+		ctx             context.Context
 		want            *err
 		wantErrIs       error
 		wantErrContains string
@@ -87,11 +94,25 @@ func Test_newError(t *testing.T) {
 				Info:        map[string]any{"msg": "hello"},
 			},
 		},
+		{
+			name:   "context-cause",
+			ctx:    canceledCtx,
+			fromOp: Op("context-cause"),
+			e:      fmt.Errorf("%s: valid: %w", "context-cause", ErrInvalidParameter),
+			want: &err{
+				ErrorFields:  fmt.Errorf("%s: valid: %w", "context-cause", ErrInvalidParameter),
+				Error:        "context-cause: valid: invalid parameter",
+				Version:      errorVersion,
+				Op:           Op("context-cause"),
+				ContextCause: errors.New("test cancel"),
+			},
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			assert, require := assert.New(t), require.New(t)
-			got, err := newError(tt.fromOp, tt.e, tt.opts...)
+			testCtx := cmp.Or(tt.ctx, ctx)
+			got, err := newError(testCtx, tt.fromOp, tt.e, tt.opts...)
 			if tt.wantErrIs != nil {
 				require.Error(err)
 				assert.Nil(got)

internal/event/eventer_retry_test.go

@@ -30,7 +30,7 @@ func TestEventer_retrySend(t *testing.T) {
 	require.NoError(t, err)
 
 	testError := fmt.Errorf("%s: missing operation: %w", "missing operation", ErrInvalidParameter)
-	testEvent, err := newError("TestEventer_retrySend", testError, WithId("test-error"))
+	testEvent, err := newError(ctx, "TestEventer_retrySend", testError, WithId("test-error"))
 	require.NoError(t, err)
 
 	tests := []struct {

internal/event/eventer_test.go

@@ -304,7 +304,7 @@ func TestEventer_writeError(t *testing.T) {
 	eventer, er := NewEventer(testLogger, testLock, "TestEventer_writeError", testSetup.EventerConfig)
 	require.NoError(t, er)
 
-	testError, er := newError("TestEventer_writeError", fmt.Errorf("%s: no msg: test", ErrIo))
+	testError, er := newError(ctx, "TestEventer_writeError", fmt.Errorf("%s: no msg: test", ErrIo))
 	require.NoError(t, er)
 
 	tests := []struct {