feat: 이벤트 디스패칭 및 WebSocket 런타임에서의 에러 처리와 동시성 개선

	•	Kafka 및 RabbitMQ 퍼블리셔에서 nil 핸들러와 write 옵션에 대한 에러 체크 추가
	•	고루틴과 동기화를 활용해 이벤트 디스패칭을 병렬 처리하도록 개선
	•	바이너리 및 리다이렉트 응답에서 포인터 타입을 지원하도록 반환값 핸들러 확장
	•	성능 향상을 위해 실행 계획을 컴파일하고 캐싱하도록 파이프라인 실행 로직 리팩토링
	•	WebSocket 런타임에서 동시 쓰기를 안전하게 처리하기 위해 mutex 기반 연결 추적 추가
	•	새로운 에러 처리 시나리오와 WebSocket 컨텍스트 파라미터 노출에 대한 테스트 추가

Author: NARUBROWN

cmd/demo/main.go

@@ -72,17 +72,23 @@ func main() {
 		}),
 	)
 
-	app.Consumers().Register(
+	if err := app.Consumers().Register(
 		"order.created",
 		(*OrderConsumer).OnCreatedKafka,
-	)
+	); err != nil {
+		panic(err)
+	}
 
-	app.Consumers().Register(
+	if err := app.Consumers().Register(
 		"stock.created",
 		(*OrderConsumer).OnCreatedRabbitMQ,
-	)
+	); err != nil {
+		panic(err)
+	}
 
-	app.WebSocket().Register("/ws/chat", (*ChatController).OnMessage)
+	if err := app.WebSocket().Register("/ws/chat", (*ChatController).OnMessage); err != nil {
+		panic(err)
+	}
 
 	// EnableGracefulShutdown & ShutdownTimeout은 선택사항입니다.
 	app.Run(boot.Options{

core/handler_meta.go

@@ -10,6 +10,8 @@ type HandlerMeta struct {
 	ControllerType reflect.Type
 	// 호출할 메서드 이름
 	Method reflect.Method
+	// 라우트에 선언된 path parameter key 순서
+	PathKeys []string
 	// 핸들러에 적용된 인터셉터
 	Interceptors []Interceptor
 }

internal/adapter/echo/adapter.go

@@ -42,9 +42,6 @@ type Server struct {
 func NewServer(pipeline *pipeline.Pipeline, address string, transportHooks []func(any), opts boot.HTTPOptions) *Server {
 	normalized := normalizeHTTPOptions(opts)
 	e := newEcho(normalized)
-	for _, hook := range transportHooks {
-		hook(e)
-	}
 
 	httpServer := &http.Server{
 		Addr:              address,
@@ -129,6 +126,9 @@ func simpleRecover() echo.MiddlewareFunc {
 
 func (s *Server) Mount() {
 	s.echo.Any("/*", s.handle)
+	for _, hook := range s.transportHooks {
+		hook(s.echo)
+	}
 }
 
 func (s *Server) Start() error {

internal/adapter/echo/context_impl.go

@@ -19,10 +19,8 @@ type echoContext struct {
 
 func NewContext(c echo.Context) core.ExecutionContext {
 	return &echoContext{
-		echo:     c,
-		reqCtx:   c.Request().Context(), // 요청시 생성되는 Context
-		store:    make(map[string]any),
-		eventBus: publish.NewEventBus(),
+		echo:   c,
+		reqCtx: c.Request().Context(), // 요청시 생성되는 Context
 	}
 }
 
@@ -35,6 +33,9 @@ func (e *echoContext) Bind(out any) error {
 }
 
 func (e *echoContext) Get(key string) (any, bool) {
+	if e.store == nil {
+		return nil, false
+	}
 	value, ok := e.store[key]
 	return value, ok
 }
@@ -64,6 +65,9 @@ func (e *echoContext) Query(name string) string {
 }
 
 func (e *echoContext) Set(key string, value any) {
+	if e.store == nil {
+		e.store = make(map[string]any)
+	}
 	e.store[key] = value
 }
 
@@ -125,5 +129,8 @@ func (e *echoContext) MultipartForm() (*multipart.Form, error) {
 }
 
 func (c *echoContext) EventBus() publish.EventBus {
+	if c.eventBus == nil {
+		c.eventBus = publish.NewEventBus()
+	}
 	return c.eventBus
 }

internal/bootstrap/bootstrap.go

@@ -87,7 +87,7 @@ func Run(config Config) error {
 			},
 		})
 		if err != nil {
-			panic(err)
+			return fmt.Errorf("[Bootstrap] Kafka publisher 초기화 실패: %w", err)
 		}
 		eventPublishers = append(eventPublishers, kafkaPublisher)
 		defer func() {
@@ -108,7 +108,7 @@ func Run(config Config) error {
 			},
 		})
 		if err != nil {
-			panic(err)
+			return fmt.Errorf("[Bootstrap] RabbitMQ writer 초기화 실패: %w", err)
 		}
 		eventPublishers = append(eventPublishers, rabbitmqWriter)
 		defer func() {
@@ -183,13 +183,13 @@ func Run(config Config) error {
 		prefix := config.HTTP.GlobalPrefix
 		if prefix != "" {
 			if !strings.HasPrefix(prefix, "/") {
-				panic("HTTP GlobalPrefix는 '/'로 시작해야 합니다")
+				return fmt.Errorf("HTTP GlobalPrefix는 '/'로 시작해야 합니다")
 			}
 			if strings.Contains(prefix, ":") {
-				panic("Path 파라미터는 HTTP GlobalPrefix에서 사용될 수 없습니다")
+				return fmt.Errorf("Path 파라미터는 HTTP GlobalPrefix에서 사용될 수 없습니다")
 			}
 			if strings.Contains(prefix, "*") {
-				panic("와일드카드는 HTTP GlobalPrefix에서 사용될 수 없습니다")
+				return fmt.Errorf("와일드카드는 HTTP GlobalPrefix에서 사용될 수 없습니다")
 			}
 			prefix = strings.TrimSuffix(prefix, "/")
 			log.Printf("[Bootstrap] HTTP GlobalPrefix 적용: %s", prefix)
@@ -212,6 +212,9 @@ func Run(config Config) error {
 			resolved := make([]core.Interceptor, len(route.Interceptors))
 			for i, interceptor := range route.Interceptors {
 				interceptorType := reflect.TypeOf(interceptor)
+				if interceptorType == nil {
+					return fmt.Errorf("[Bootstrap] Route Interceptor[%d]가 nil입니다", i)
+				}
 				value := reflect.ValueOf(interceptor)
 
 				// 같은 타입의 인터셉터 로깅은 한 번만 남긴다.
@@ -225,7 +228,7 @@ func Run(config Config) error {
 
 					inst, err := container.Resolve(interceptorType)
 					if err != nil {
-						panic(err)
+						return fmt.Errorf("[Bootstrap] Route Interceptor 생성 실패: %w", err)
 					}
 					resolved[i] = inst.(core.Interceptor)
 				} else {
@@ -238,10 +241,15 @@ func Run(config Config) error {
 			}
 
 			meta.Interceptors = resolved
-			fullPath := joinPath(prefix, route.Path)
+			fullPath, err := joinPath(prefix, route.Path)
+			if err != nil {
+				return err
+			}
 			log.Printf("[Bootstrap] HTTP 라우트 등록 : (%s) %s", route.Method, fullPath)
 
-			assertNoAmbiguousRoute(route.Method, fullPath, registeredPathsByMethod[route.Method])
+			if err := assertNoAmbiguousRoute(route.Method, fullPath, registeredPathsByMethod[route.Method]); err != nil {
+				return err
+			}
 			registeredPathsByMethod[route.Method] = append(registeredPathsByMethod[route.Method], fullPath)
 
 			router.Register(route.Method, fullPath, meta)
@@ -250,8 +258,7 @@ func Run(config Config) error {
 		log.Println("[Bootstrap] 컨트롤러 의존성 Warm-up 시작")
 		// Warm-Up Component
 		if err := container.WarmUp(router.ControllerTypes()); err != nil {
-			// Warm-up 실패시 panic
-			panic(err)
+			return fmt.Errorf("[Bootstrap] HTTP 컨트롤러 Warm-up 실패: %w", err)
 		}
 
 		log.Println("[Bootstrap] 실행 파이프라인 구성")
@@ -319,13 +326,16 @@ func Run(config Config) error {
 		for _, interceptor := range ordered {
 			v := reflect.ValueOf(interceptor)
 			t := reflect.TypeOf(interceptor)
+			if t == nil {
+				return fmt.Errorf("[Bootstrap] Interceptor가 nil입니다")
+			}
 
 			if t.Kind() == reflect.Pointer && v.IsNil() {
 				log.Printf("[Bootstrap] Interceptor %s가 컨테이너에서 생성됐습니다.", t.Elem().Name())
 
 				inst, err := container.Resolve(t)
 				if err != nil {
-					panic(err)
+					return fmt.Errorf("[Bootstrap] Interceptor 생성 실패: %w", err)
 				}
 
 				httpPipeline.AddInterceptor(inst.(core.Interceptor))
@@ -351,7 +361,7 @@ func Run(config Config) error {
 			defer wsRuntime.Stop()
 
 			// Echo Transport Hook으로 마운트
-			config.TransportHooks = append(config.TransportHooks, func(e any) {
+			wsMountHook := func(e any) {
 				echoInstance, ok := e.(*echo.Echo)
 				if !ok {
 					return
@@ -363,7 +373,8 @@ func Run(config Config) error {
 						return nil
 					})
 				}
-			})
+			}
+			config.TransportHooks = append([]func(any){wsMountHook}, config.TransportHooks...)
 		}
 
 		// Echo Adapter
@@ -390,7 +401,7 @@ func Run(config Config) error {
 			consumerTypes = append(consumerTypes, reg.Meta.ControllerType)
 		}
 		if err := container.WarmUp(consumerTypes); err != nil {
-			panic(err)
+			return fmt.Errorf("[Bootstrap] Consumer 컨트롤러 Warm-up 실패: %w", err)
 		}
 	}
 
@@ -419,7 +430,7 @@ func Run(config Config) error {
 		)
 
 		if err := runtime.Validate(); err != nil {
-			panic(err)
+			return fmt.Errorf("[Bootstrap] Kafka consumer 검증 실패: %w", err)
 		}
 
 		forwardConsumerErrors("Kafka", runtime, consumerErrCh)
@@ -451,7 +462,7 @@ func Run(config Config) error {
 		)
 
 		if err := runtime.Validate(); err != nil {
-			panic(err)
+			return fmt.Errorf("[Bootstrap] RabbitMQ consumer 검증 실패: %w", err)
 		}
 
 		forwardConsumerErrors("RabbitMQ", runtime, consumerErrCh)
@@ -539,23 +550,23 @@ func Run(config Config) error {
 	return nil
 }
 
-func joinPath(prefix, path string) string {
+func joinPath(prefix, path string) (string, error) {
 	if path == "" {
-		panic("라우트 Path는 비어있을 수 없습니다")
+		return "", fmt.Errorf("라우트 Path는 비어있을 수 없습니다")
 	}
 
 	if !strings.HasPrefix(path, "/") {
 		path = "/" + path
 	}
 
 	if prefix == "" {
-		return path
+		return path, nil
 	}
 
-	return prefix + path
+	return prefix + path, nil
 }
 
-func assertNoAmbiguousRoute(method, newPath string, existing []string) {
+func assertNoAmbiguousRoute(method, newPath string, existing []string) error {
 	newSegs := splitPathForValidation(newPath)
 
 	for _, oldPath := range existing {
@@ -583,12 +594,13 @@ func assertNoAmbiguousRoute(method, newPath string, existing []string) {
 		}
 
 		if overlaps {
-			panic(fmt.Sprintf(
+			return fmt.Errorf(
 				"[Router] 모호한 라우트가 감지되었습니다 (부트 타임): method=%s, 신규=%s 가 기존=%s 와 충돌합니다",
 				method, newPath, oldPath,
-			))
+			)
 		}
 	}
+	return nil
 }
 
 func splitPathForValidation(path string) []string {
@@ -613,13 +625,19 @@ func isPathParam(seg string) bool {
 // forwardConsumerErrors는 특정 런타임의 치명적 에러를 공용 채널로 전달한다.
 func forwardConsumerErrors(name string, runtime *consumer.Runtime, out chan<- error) {
 	go func() {
-		if err := <-runtime.Errors(); err != nil {
+		select {
+		case err := <-runtime.Errors():
+			if err == nil {
+				return
+			}
 			wrapped := fmt.Errorf("[Bootstrap] %s consumer runtime error: %w", name, err)
 			select {
 			case out <- wrapped:
 			default:
 				log.Printf("%v (consumerErrCh가 가득 차 전파하지 못했습니다)", wrapped)
 			}
+		case <-runtime.Done():
+			return
 		}
 	}()
 }