fix: use runtime.HTTPPattern for route extraction in spans

config/README.md

@@ -65,7 +65,7 @@ import "github.com/go-coldbrew/core/config"
 
 
 <a name="Config"></a>
-## type [Config](<https://github.com/go-coldbrew/core/blob/main/config/config.go#L6-L137>)
+## type [Config](<https://github.com/go-coldbrew/core/blob/main/config/config.go#L6-L138>)
 
 Config is the configuration for the Coldbrew server It is populated from environment variables and has sensible defaults for all fields so that you can just use it as is without any configuration The following environment variables are supported and can be used to override the defaults for the fields
 
@@ -195,14 +195,15 @@ type Config struct {
     // OTLPSamplingRatio is the ratio of traces to sample (0.0 to 1.0)
     // 1.0 means sample all traces, 0.1 means sample 10% of traces
     OTLPSamplingRatio float64 `envconfig:"OTLP_SAMPLING_RATIO" default:"0.2"`
-    // OTLPUseOpenTracingBridge determines whether to set up OpenTracing compatibility bridge
-    // This allows using existing OpenTracing instrumentation with OpenTelemetry
-    OTLPUseOpenTracingBridge bool `envconfig:"OTLP_USE_OPENTRACING_BRIDGE" default:"true"`
+    // Deprecated: OpenTracing bridge is provided for backwards compatibility only.
+    // New services should leave this false (the default). Set to true only if you
+    // have existing OpenTracing instrumentation that hasn't been migrated to OTEL.
+    OTLPUseOpenTracingBridge bool `envconfig:"OTLP_USE_OPENTRACING_BRIDGE" default:"false"`
 }
 ```
 
 <a name="Config.Validate"></a>
-### func \(Config\) [Validate](<https://github.com/go-coldbrew/core/blob/main/config/config.go#L142>)
+### func \(Config\) [Validate](<https://github.com/go-coldbrew/core/blob/main/config/config.go#L143>)
 
 ```go
 func (c Config) Validate() []string

core.go

@@ -9,6 +9,7 @@ import (
 	"net"
 	"net/http"
 	"net/http/pprof"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -24,8 +25,10 @@ import (
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	"go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc"
 	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
 	"go.opentelemetry.io/otel/propagation"
-	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
 	oteltrace "go.opentelemetry.io/otel/trace"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials"
@@ -169,37 +172,134 @@ func (c *cb) processConfig() {
 	}
 }
 
+// statusRecorder wraps http.ResponseWriter to capture the final HTTP status code.
+// It records the first status >= 200, plus 101 Switching Protocols (which is
+// terminal). Other 1xx statuses are informational and skipped.
+// Unwrap() is provided for http.ResponseController (Go 1.20+) to access optional
+// interfaces (http.Flusher, http.Hijacker, etc.) from the underlying writer.
+type statusRecorder struct {
+	http.ResponseWriter
+	status      int
+	wroteHeader bool
+}
+
+func (sr *statusRecorder) WriteHeader(code int) {
+	if !sr.wroteHeader && (code >= 200 || code == http.StatusSwitchingProtocols) {
+		sr.status = code
+		sr.wroteHeader = true
+	}
+	sr.ResponseWriter.WriteHeader(code)
+}
+
+func (sr *statusRecorder) Write(b []byte) (int, error) {
+	if !sr.wroteHeader {
+		sr.status = http.StatusOK
+		sr.wroteHeader = true
+	}
+	return sr.ResponseWriter.Write(b)
+}
+
+// Unwrap returns the underlying ResponseWriter so that http.ResponseController
+// and middleware can access optional interfaces (http.Flusher, http.Hijacker, etc.).
+func (sr *statusRecorder) Unwrap() http.ResponseWriter {
+	return sr.ResponseWriter
+}
+
+// endSpan records the HTTP status code on the span, marks it as error for 5xx, and ends it.
+func endSpan(span oteltrace.Span, rec *statusRecorder) {
+	span.SetAttributes(semconv.HTTPResponseStatusCode(rec.status))
+	if rec.status >= 500 {
+		span.SetStatus(codes.Error, http.StatusText(rec.status))
+	}
+	span.End()
+}
+
+// httpSpanAttributes returns the OTEL attributes for an incoming HTTP request,
+// omitting empty-valued attributes (e.g. scheme behind a reverse proxy).
+func httpSpanAttributes(r *http.Request) []attribute.KeyValue {
+	host, port, err := net.SplitHostPort(r.Host)
+	if err != nil {
+		host = r.Host
+	}
+	host = strings.TrimPrefix(strings.TrimSuffix(host, "]"), "[")
+	attrs := []attribute.KeyValue{
+		semconv.HTTPRequestMethodKey.String(r.Method),
+		semconv.URLPath(r.URL.Path),
+	}
+	if host != "" {
+		attrs = append(attrs, semconv.ServerAddress(host))
+	}
+	if port != "" {
+		if p, err := strconv.Atoi(port); err == nil {
+			attrs = append(attrs, semconv.ServerPort(p))
+		}
+	}
+	if r.URL.RawQuery != "" {
+		attrs = append(attrs, semconv.URLQuery(r.URL.RawQuery))
+	}
+	scheme := r.URL.Scheme
+	if scheme == "" {
+		if r.TLS != nil {
+			scheme = "https"
+		} else {
+			scheme = "http"
+		}
+	}
+	attrs = append(attrs, semconv.URLScheme(scheme))
+	return attrs
+}
+
 // tracingWrapper is a middleware that creates a new OTEL span for each incoming HTTP request.
 // It extracts any propagated trace context from the request headers and, for non-filtered
 // methods, starts a server span that is attached to the request context.
 func tracingWrapper(h http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		prop := otel.GetTextMapPropagator()
-		ctx := prop.Extract(r.Context(), propagation.HeaderCarrier(r.Header))
+		ctx := otel.GetTextMapPropagator().Extract(r.Context(), propagation.HeaderCarrier(r.Header))
+
 		if interceptors.FilterMethodsFunc(ctx, r.URL.Path) {
 			var serverSpan oteltrace.Span
-			ctx, serverSpan = otel.Tracer("coldbrew-http").Start(ctx, "ServeHTTP",
+			ctx, serverSpan = otel.Tracer("coldbrew-http").Start(ctx, r.Method,
 				oteltrace.WithSpanKind(oteltrace.SpanKindServer),
-				oteltrace.WithAttributes(
-					semconv.HTTPMethodKey.String(r.Method),
-					semconv.HTTPTargetKey.String(r.URL.RequestURI()),
-				),
+				oteltrace.WithAttributes(httpSpanAttributes(r)...),
 			)
-			r = r.WithContext(ctx)
-			defer serverSpan.End()
-		} else {
-			r = r.WithContext(ctx)
+			rec := &statusRecorder{ResponseWriter: w, status: http.StatusOK}
+			w = rec
+			defer func() {
+				if recovered := recover(); recovered != nil {
+					if !rec.wroteHeader {
+						rec.status = http.StatusInternalServerError
+					}
+					serverSpan.RecordError(fmt.Errorf("panic: %v", recovered))
+					endSpan(serverSpan, rec)
+					panic(recovered)
+				}
+				endSpan(serverSpan, rec)
+			}()
 		}
+
 		_, han := interceptors.NRHttpTracer("", h.ServeHTTP)
-		// add this info to log
-		ctx = r.Context()
 		ctx = options.AddToOptions(ctx, "", "")
 		ctx = loggers.AddToLogContext(ctx, "httpPath", r.URL.Path)
-		r = r.WithContext(ctx)
-		han(w, r)
+		han(w, r.WithContext(ctx))
 	})
 }
 
+// spanRouteMiddleware is a grpc-gateway middleware that updates the OTEL span
+// name and http.route attribute with the matched route pattern after routing.
+// It uses runtime.HTTPPattern (the Pattern struct set by handleHandler) rather
+// than runtime.HTTPPathPattern (the string set later inside AnnotateContext).
+func spanRouteMiddleware(next runtime.HandlerFunc) runtime.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) {
+		if pattern, ok := runtime.HTTPPattern(r.Context()); ok {
+			route := pattern.String()
+			span := oteltrace.SpanFromContext(r.Context())
+			span.SetName(r.Method + " " + route)
+			span.SetAttributes(semconv.HTTPRoute(route))
+		}
+		next(w, r, pathParams)
+	}
+}
+
 // getCustomHeaderMatcher returns a matcher that matches the given header and prefix
 func getCustomHeaderMatcher(prefixes []string, header string) func(string) (string, bool) {
 	header = strings.ToLower(header)
@@ -239,6 +339,7 @@ func (c *cb) initHTTP(ctx context.Context) (*http.Server, error) {
 		),
 		runtime.WithMarshalerOption("application/proto", pMar),
 		runtime.WithMarshalerOption("application/protobuf", pMar),
+		runtime.WithMiddlewares(spanRouteMiddleware),
 	}
 
 	if c.config.UseJSONBuiltinMarshaller {