Handle unknown log types gracefully with body passthrough

Bob sends log type 14 which was causing a fatal parse error and
infinite reconnect loop. Unknown log types now pass through the raw
body as a generic map instead of erroring, making the bridge
forward-compatible with new bob log types.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: 0xluk

bob-events-bridge/internal/bob/events.go

@@ -109,8 +109,8 @@ type CustomMessageBody struct {
 }
 
 // ParseEventBody unmarshals the raw body JSON into the typed struct for the
-// given log type. Returns the typed struct as interface{}. Returns an error if
-// the log type is unknown or the body is malformed.
+// given log type. Returns the typed struct as interface{}. Unknown log types
+// are parsed as a generic map[string]any so they pass through without error.
 func ParseEventBody(logType uint32, body json.RawMessage) (interface{}, error) {
 	if len(body) == 0 {
 		return nil, nil
@@ -139,7 +139,12 @@ func ParseEventBody(logType uint32, body json.RawMessage) (interface{}, error) {
 	case LogTypeCustomMessage:
 		target = &CustomMessageBody{}
 	default:
-		return nil, fmt.Errorf("unknown log type: %d", logType)
+		// Unknown log type — pass through the raw body as a generic map
+		var m map[string]interface{}
+		if err := json.Unmarshal(body, &m); err != nil {
+			return nil, fmt.Errorf("failed to unmarshal body for unknown log type %d: %w", logType, err)
+		}
+		return m, nil
 	}
 
 	if err := json.Unmarshal(body, target); err != nil {

bob-events-bridge/internal/bob/events_test.go

@@ -179,9 +179,11 @@ func TestParseEventBody_UnknownLogType(t *testing.T) {
 	body := json.RawMessage(`{"foo": "bar"}`)
 
 	result, err := ParseEventBody(999, body)
-	assert.Nil(t, result)
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "unknown log type: 999")
+	require.NoError(t, err)
+
+	parsed, ok := result.(map[string]interface{})
+	require.True(t, ok, "unknown log type should return map[string]interface{}")
+	assert.Equal(t, "bar", parsed["foo"])
 }
 
 func TestParseEventBody_MalformedBody(t *testing.T) {

bob-events-bridge/internal/e2e/e2e_test.go

@@ -1380,6 +1380,25 @@ func TestE2E_LogType255_CustomMessage(t *testing.T) {
 	})
 }
 
+func TestE2E_UnknownLogType_Passthrough(t *testing.T) {
+	runLogTypeE2ETest(t, logTypeTestCase{
+		name:      "unknown_log_type_14",
+		eventType: 14,
+		bobBody: map[string]any{
+			"someField":    "someValue",
+			"anotherField": 42,
+		},
+		grpcChecks: map[string]any{
+			"someField":    "someValue",
+			"anotherField": float64(42),
+		},
+		kafkaChecks: map[string]any{
+			"someField":    "someValue",
+			"anotherField": float64(42),
+		},
+	})
+}
+
 // TestE2E_KafkaPublishFailure tests that processor disconnects and retries on Kafka failure
 func TestE2E_KafkaPublishFailure(t *testing.T) {
 	mockBob := NewMockBobServer(145, 22000000)

bob-events-bridge/internal/kafka/message.go

@@ -94,6 +94,10 @@ func TransformEventBody(eventType uint32, body interface{}) (map[string]any, err
 			"customMessage": b.CustomMessage,
 		}, nil
 
+	case map[string]any:
+		// Unknown log type — pass through as-is
+		return b, nil
+
 	default:
 		return nil, fmt.Errorf("unsupported event body type: %T", body)
 	}

bob-events-bridge/internal/kafka/message_test.go

@@ -201,6 +201,24 @@ func TestTransformEventBody_CustomMessage(t *testing.T) {
 	}
 }
 
+func TestTransformEventBody_UnknownLogTypePassthrough(t *testing.T) {
+	body := map[string]any{
+		"foo": "bar",
+		"num": float64(42),
+	}
+
+	result, err := TransformEventBody(999, body)
+	require.NoError(t, err)
+
+	expected := map[string]any{
+		"foo": "bar",
+		"num": float64(42),
+	}
+	if diff := cmp.Diff(expected, result); diff != "" {
+		t.Errorf("mismatch (-want +got):\n%s", diff)
+	}
+}
+
 func TestTransformEventBody_UnsupportedType(t *testing.T) {
 	body := struct{ Foo string }{Foo: "bar"}
 	_, err := TransformEventBody(99, &body)