feat(contrib/gin-gonic/gin): add WithStatusCheck and WithUseGinErrors options

contrib/gin-gonic/gin/gintrace.go

@@ -7,6 +7,7 @@
 package gin // import "github.com/DataDog/dd-trace-go/contrib/gin-gonic/gin/v2"
 
 import (
+	"errors"
 	"fmt"
 	"math"
 
@@ -53,7 +54,15 @@ func Middleware(service string, opts ...Option) gin.HandlerFunc {
 		opts = append(opts, httptrace.HeaderTagsFromRequest(c.Request, cfg.headerTags))
 		span, ctx, finishSpans := httptrace.StartRequestSpan(c.Request, opts...)
 		defer func() {
-			finishSpans(c.Writer.Status(), nil)
+			status := c.Writer.Status()
+			if cfg.propagateError && cfg.isStatusError(status) {
+				var err error
+				for _, e := range c.Errors {
+					err = errors.Join(err, e.Err)
+				}
+				finishSpans(status, cfg.isStatusError, tracer.WithError(err))
+			}
+			finishSpans(status, cfg.isStatusError)
 		}()
 
 		// pass the span through the request context

contrib/gin-gonic/gin/gintrace_test.go

@@ -179,14 +179,84 @@ func TestError(t *testing.T) {
 	mt := mocktracer.Start()
 	defer mt.Stop()
 
-	// setup
-	router := gin.New()
-	router.Use(Middleware("foobar"))
 	responseErr := errors.New("oh no")
 
-	t.Run("server error", func(*testing.T) {
+	t.Run("server error - with error propagation", func(*testing.T) {
+		defer mt.Reset()
+
+		router := gin.New()
+		router.Use(Middleware("foobar", WithErrorPropagation()))
+
+		// configure a handler that returns an error and 5xx status code
+		router.GET("/server_err", func(c *gin.Context) {
+			c.AbortWithError(500, responseErr)
+		})
+		r := httptest.NewRequest("GET", "/server_err", nil)
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, r)
+		response := w.Result()
+		defer response.Body.Close()
+		assert.Equal(response.StatusCode, 500)
+
+		// verify the errors and status are correct
+		spans := mt.FinishedSpans()
+		assert.Len(spans, 1)
+		if len(spans) < 1 {
+			t.Fatalf("no spans")
+		}
+		span := spans[0]
+		assert.Equal("http.request", span.OperationName())
+		assert.Equal("foobar", span.Tag(ext.ServiceName))
+		assert.Equal("500", span.Tag(ext.HTTPCode))
+		assert.Equal(fmt.Sprintf("Error #01: %s\n", responseErr), span.Tag("gin.errors"))
+		// server errors set the ext.ErrorMsg tag
+		assert.Equal("oh no", span.Tag(ext.ErrorMsg))
+		assert.Equal(ext.SpanKindServer, span.Tag(ext.SpanKind))
+		assert.Equal("gin-gonic/gin", span.Tag(ext.Component))
+		assert.Equal(componentName, span.Integration())
+	})
+
+	t.Run("server error - with error propagation - nil Errors in gin context", func(*testing.T) {
+		defer mt.Reset()
+
+		router := gin.New()
+		router.Use(Middleware("foobar", WithErrorPropagation()))
+
+		// configure a handler that returns an error and 5xx status code
+		router.GET("/server_err", func(c *gin.Context) {
+			c.AbortWithStatus(500)
+		})
+		r := httptest.NewRequest("GET", "/server_err", nil)
+		w := httptest.NewRecorder()
+		router.ServeHTTP(w, r)
+		response := w.Result()
+		defer response.Body.Close()
+		assert.Equal(response.StatusCode, 500)
+
+		// verify the errors and status are correct
+		spans := mt.FinishedSpans()
+		assert.Len(spans, 1)
+		if len(spans) < 1 {
+			t.Fatalf("no spans")
+		}
+		span := spans[0]
+		assert.Equal("http.request", span.OperationName())
+		assert.Equal("foobar", span.Tag(ext.ServiceName))
+		assert.Equal("500", span.Tag(ext.HTTPCode))
+		assert.Empty(span.Tag("gin.errors"))
+		// server errors set the ext.ErrorMsg tag
+		assert.Equal("500: Internal Server Error", span.Tag(ext.ErrorMsg))
+		assert.Equal(ext.SpanKindServer, span.Tag(ext.SpanKind))
+		assert.Equal("gin-gonic/gin", span.Tag(ext.Component))
+		assert.Equal(componentName, span.Integration())
+	})
+
+	t.Run("server error - without error propagation", func(*testing.T) {
 		defer mt.Reset()
 
+		router := gin.New()
+		router.Use(Middleware("foobar"))
+
 		// configure a handler that returns an error and 5xx status code
 		router.GET("/server_err", func(c *gin.Context) {
 			c.AbortWithError(500, responseErr)
@@ -219,6 +289,9 @@ func TestError(t *testing.T) {
 	t.Run("client error", func(*testing.T) {
 		defer mt.Reset()
 
+		router := gin.New()
+		router.Use(Middleware("foobar"))
+
 		// configure a handler that returns an error and 4xx status code
 		router.GET("/client_err", func(c *gin.Context) {
 			c.AbortWithError(418, responseErr)

contrib/gin-gonic/gin/option.go

@@ -15,11 +15,13 @@ import (
 )
 
 type config struct {
-	analyticsRate float64
-	resourceNamer func(c *gin.Context) string
-	serviceName   string
-	ignoreRequest func(c *gin.Context) bool
-	headerTags    instrumentation.HeaderTags
+	analyticsRate  float64
+	resourceNamer  func(c *gin.Context) string
+	serviceName    string
+	ignoreRequest  func(c *gin.Context) bool
+	isStatusError  func(statusCode int) bool
+	propagateError bool
+	headerTags     instrumentation.HeaderTags
 }
 
 func newConfig(serviceName string) *config {
@@ -28,11 +30,13 @@ func newConfig(serviceName string) *config {
 	}
 	rate := instr.AnalyticsRate(true)
 	return &config{
-		analyticsRate: rate,
-		resourceNamer: defaultResourceNamer,
-		serviceName:   serviceName,
-		ignoreRequest: func(_ *gin.Context) bool { return false },
-		headerTags:    instr.HTTPHeadersAsTags(),
+		analyticsRate:  rate,
+		resourceNamer:  defaultResourceNamer,
+		serviceName:    serviceName,
+		ignoreRequest:  func(_ *gin.Context) bool { return false },
+		isStatusError:  isServerError,
+		propagateError: false,
+		headerTags:     instr.HTTPHeadersAsTags(),
 	}
 }
 
@@ -79,6 +83,26 @@ func WithResourceNamer(namer func(c *gin.Context) string) OptionFn {
 	}
 }
 
+// WithStatusCheck specifies a function fn which reports whether the passed
+// statusCode should be considered an error.
+func WithStatusCheck(fn func(statusCode int) bool) OptionFn {
+	return func(cfg *config) {
+		cfg.isStatusError = fn
+	}
+}
+
+func isServerError(statusCode int) bool {
+	return statusCode >= 500 && statusCode < 600
+}
+
+// WithErrorPropagation enables the propagation of gin's errors to the span.
+// If there are multiple errors in the gin context, they will be all added to the span.
+func WithErrorPropagation() OptionFn {
+	return func(cfg *config) {
+		cfg.propagateError = true
+	}
+}
+
 // WithHeaderTags enables the integration to attach HTTP request headers as span tags.
 // Warning:
 // Using this feature can risk exposing sensitive data such as authorization tokens to Datadog.