chore: remove resolved plan for JSON attribute escaping

internal/observability/fx.go

@@ -20,13 +20,28 @@ func (fxLogger) LogEvent(event fxevent.Event) {
 }
 
 func describeFXEventError(event fxevent.Event) (string, map[string]any, error) {
+	if eventName, fields, ok, err := describeFXBuildEventError(event); ok {
+		return eventName, fields, err
+	}
+
+	return describeFXLifecycleEventError(event)
+}
+
+func describeFXBuildEventError(event fxevent.Event) (string, map[string]any, bool, error) {
 	switch e := event.(type) {
 	case *fxevent.Provided:
-		return "fx_provide_failed", map[string]any{"constructor": e.ConstructorName}, e.Err
+		return "fx_provide_failed", map[string]any{"constructor": e.ConstructorName}, true, e.Err
 	case *fxevent.Invoked:
-		return "fx_invoke_failed", map[string]any{"function": e.FunctionName}, e.Err
+		return "fx_invoke_failed", map[string]any{"function": e.FunctionName}, true, e.Err
 	case *fxevent.Run:
-		return "fx_run_failed", map[string]any{"function": e.Name, "kind": e.Kind}, e.Err
+		return "fx_run_failed", map[string]any{"function": e.Name, "kind": e.Kind}, true, e.Err
+	default:
+		return "", nil, false, nil
+	}
+}
+
+func describeFXLifecycleEventError(event fxevent.Event) (string, map[string]any, error) {
+	switch e := event.(type) {
 	case *fxevent.OnStartExecuted:
 		return "fx_on_start_failed", map[string]any{"caller": e.CallerName, "function": e.FunctionName, "runtime": e.Runtime}, e.Err
 	case *fxevent.OnStopExecuted:

internal/observability/fx_test.go

@@ -0,0 +1,119 @@
+package observability
+
+import (
+	"errors"
+	"reflect"
+	"testing"
+	"time"
+
+	"go.uber.org/fx/fxevent"
+)
+
+func TestDescribeFXEventErrorDescribesFailedBuildEvents(t *testing.T) {
+	err := errors.New("fx failed")
+
+	tests := map[string]struct {
+		event      fxevent.Event
+		wantName   string
+		wantFields map[string]any
+	}{
+		"provided": {
+			event:      &fxevent.Provided{ConstructorName: "newServer", Err: err},
+			wantName:   "fx_provide_failed",
+			wantFields: map[string]any{"constructor": "newServer"},
+		},
+		"invoked": {
+			event:      &fxevent.Invoked{FunctionName: "startServer", Err: err},
+			wantName:   "fx_invoke_failed",
+			wantFields: map[string]any{"function": "startServer"},
+		},
+		"run": {
+			event:      &fxevent.Run{Name: "newRepo", Kind: "provide", Err: err},
+			wantName:   "fx_run_failed",
+			wantFields: map[string]any{"function": "newRepo", "kind": "provide"},
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			assertFXEventError(t, tt.event, tt.wantName, tt.wantFields, err)
+		})
+	}
+}
+
+func TestDescribeFXEventErrorDescribesFailedLifecycleEvents(t *testing.T) {
+	err := errors.New("fx failed")
+	runtime := 12 * time.Millisecond
+
+	tests := map[string]struct {
+		event      fxevent.Event
+		wantName   string
+		wantFields map[string]any
+	}{
+		"on start executed": {
+			event:      &fxevent.OnStartExecuted{CallerName: "server", FunctionName: "listen", Runtime: runtime, Err: err},
+			wantName:   "fx_on_start_failed",
+			wantFields: map[string]any{"caller": "server", "function": "listen", "runtime": runtime},
+		},
+		"on stop executed": {
+			event:      &fxevent.OnStopExecuted{CallerName: "server", FunctionName: "close", Runtime: runtime, Err: err},
+			wantName:   "fx_on_stop_failed",
+			wantFields: map[string]any{"caller": "server", "function": "close", "runtime": runtime},
+		},
+		"started": {
+			event:    &fxevent.Started{Err: err},
+			wantName: "fx_start_failed",
+		},
+		"stopped": {
+			event:    &fxevent.Stopped{Err: err},
+			wantName: "fx_stop_failed",
+		},
+		"rolling back": {
+			event:    &fxevent.RollingBack{StartErr: err},
+			wantName: "fx_rollback_start",
+		},
+		"rolled back": {
+			event:    &fxevent.RolledBack{Err: err},
+			wantName: "fx_rollback_failed",
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			assertFXEventError(t, tt.event, tt.wantName, tt.wantFields, err)
+		})
+	}
+}
+
+func assertFXEventError(t *testing.T, event fxevent.Event, wantName string, wantFields map[string]any, wantErr error) {
+	t.Helper()
+
+	gotName, gotFields, gotErr := describeFXEventError(event)
+
+	if gotName != wantName {
+		t.Fatalf("event name = %q, want %q", gotName, wantName)
+	}
+	if !reflect.DeepEqual(gotFields, wantFields) {
+		t.Fatalf("fields = %#v, want %#v", gotFields, wantFields)
+	}
+	if !errors.Is(gotErr, wantErr) {
+		t.Fatalf("error = %v, want %v", gotErr, wantErr)
+	}
+}
+
+func TestDescribeFXEventErrorIgnoresEventsWithoutErrors(t *testing.T) {
+	tests := map[string]fxevent.Event{
+		"provided": &fxevent.Provided{ConstructorName: "newServer"},
+		"unknown":  &fxevent.Supplied{},
+	}
+
+	for name, event := range tests {
+		t.Run(name, func(t *testing.T) {
+			_, _, gotErr := describeFXEventError(event)
+
+			if gotErr != nil {
+				t.Fatalf("error = %v, want nil", gotErr)
+			}
+		})
+	}
+}