feat: add TraceIgnoreStatusCodes option (#1089)

Author: giortzisg

_examples/trace-ignore-status-codes/main.go

@@ -0,0 +1,93 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/getsentry/sentry-go"
+	sentryhttp "github.com/getsentry/sentry-go/http"
+)
+
+func main() {
+	// Initialize Sentry with TraceIgnoreStatusCodes configuration
+	err := sentry.Init(sentry.ClientOptions{
+		Dsn:              "", // Replace with your DSN
+		Debug:            true,
+		EnableTracing:    true,
+		TracesSampleRate: 1.0,
+		// Configure which HTTP status codes should not be traced
+		// Each element can be a single code {code} or a range {min, max}
+		TraceIgnoreStatusCodes: [][]int{{404}, {500, 599}}, // Ignore 404 and server errors 500-599
+	})
+	if err != nil {
+		log.Fatalf("sentry.Init: %s", err)
+	}
+
+	defer sentry.Flush(2 * time.Second)
+
+	// Create a Sentry-instrumented HTTP handler
+	sentryHandler := sentryhttp.New(sentryhttp.Options{})
+
+	http.HandleFunc("/", sentryHandler.HandleFunc(homeHandler))
+	http.HandleFunc("/users/", sentryHandler.HandleFunc(usersHandler))
+	http.HandleFunc("/forbidden", sentryHandler.HandleFunc(forbiddenHandler))
+	http.HandleFunc("/error", sentryHandler.HandleFunc(errorHandler))
+
+	fmt.Println("Server starting on :8080")
+	fmt.Println("Try these endpoints:")
+	fmt.Println("  GET /             - Returns 200 OK (will be traced)")
+	fmt.Println("  GET /users/123     - Returns 200 OK (will be traced)")
+	fmt.Println("  GET /nonexistent  - Returns 404 Not Found (will NOT be traced - matches {404})")
+	fmt.Println("  GET /forbidden    - Returns 403 Forbidden (will be traced)")
+	fmt.Println("  GET /error        - Returns 500 Internal Server Error (will NOT be traced - in range {500, 599})")
+
+	log.Fatal(http.ListenAndServe(":8080", nil))
+}
+
+func homeHandler(w http.ResponseWriter, r *http.Request) {
+	if r.URL.Path != "/" {
+		// This will return 404 and won't be traced due to our configuration (matches {404})
+		http.NotFound(w, r)
+		return
+	}
+
+	if span := sentry.SpanFromContext(r.Context()); span != nil {
+		span.SetTag("endpoint", "home")
+		span.SetData("custom_data", "This is the home page")
+	}
+
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprintf(w, "Welcome to the home page! This 200 response will be traced.\n")
+}
+
+func usersHandler(w http.ResponseWriter, r *http.Request) {
+	if span := sentry.SpanFromContext(r.Context()); span != nil {
+		span.SetTag("endpoint", "users")
+		span.SetData("user_id", r.URL.Path[7:])
+	}
+
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprintf(w, "User profile page. This 200 response will be traced.\n")
+}
+
+func forbiddenHandler(w http.ResponseWriter, r *http.Request) {
+	if span := sentry.SpanFromContext(r.Context()); span != nil {
+		span.SetTag("endpoint", "forbidden")
+		span.SetData("reason", "Access denied")
+	}
+
+	w.WriteHeader(http.StatusForbidden)
+	fmt.Fprintf(w, "Access forbidden. This 403 response will be traced.\n")
+}
+
+func errorHandler(w http.ResponseWriter, r *http.Request) {
+	if span := sentry.SpanFromContext(r.Context()); span != nil {
+		span.SetTag("endpoint", "error")
+		span.SetData("error_type", "simulated_server_error")
+	}
+
+	w.WriteHeader(http.StatusInternalServerError)
+	fmt.Fprintf(w, "Internal server error. This 500 response will NOT be traced (in range 500-599).\n")
+}

client.go

@@ -228,6 +228,21 @@ type ClientOptions struct {
 	Tags map[string]string
 	// EnableLogs controls when logs should be emitted.
 	EnableLogs bool
+	// TraceIgnoreStatusCodes is a list of HTTP status codes that should not be traced.
+	// Each element can be either:
+	// - A single-element slice [code] for a specific status code
+	// - A two-element slice [min, max] for a range of status codes (inclusive)
+	// When an HTTP request results in a status code that matches any of these codes or ranges,
+	// the transaction will not be sent to Sentry.
+	//
+	// Examples:
+	//   [][]int{{404}}                           // ignore only status code 404
+	//   [][]int{{400, 405}}                     // ignore status codes 400-405
+	//   [][]int{{404}, {500}}                   // ignore status codes 404 and 500
+	//   [][]int{{404}, {400, 405}, {500, 599}}  // ignore 404, range 400-405, and range 500-599
+	//
+	// By default, this is empty and all status codes are traced.
+	TraceIgnoreStatusCodes [][]int
 }
 
 // Client is the underlying processor that is used by the main API and Hub

client_test.go

@@ -699,6 +699,132 @@ func TestIgnoreTransactions(t *testing.T) {
 	}
 }
 
+func TestTraceIgnoreStatusCode_EmptyCode(t *testing.T) {
+	transport := &MockTransport{}
+	ctx := NewTestContext(ClientOptions{
+		EnableTracing:    true,
+		TracesSampleRate: 1.0,
+		Transport:        transport,
+	})
+
+	transaction := StartTransaction(ctx, "test")
+	// Transaction has no http.response.status_code
+	transaction.Finish()
+
+	dropped := transport.lastEvent == nil
+	assertEqual(t, dropped, false, "expected transaction to not be dropped")
+}
+
+func TestTraceIgnoreStatusCodes(t *testing.T) {
+	tests := map[string]struct {
+		ignoreStatusCodes [][]int
+		statusCode        interface{}
+		expectDrop        bool
+	}{
+		"No ignored codes": {
+			statusCode:        404,
+			ignoreStatusCodes: [][]int{},
+			expectDrop:        false,
+		},
+		"Status code not in ignore ranges": {
+			statusCode:        500,
+			ignoreStatusCodes: [][]int{{400, 405}},
+			expectDrop:        false,
+		},
+		"404 in ignore range": {
+			statusCode:        404,
+			ignoreStatusCodes: [][]int{{400, 405}},
+			expectDrop:        true,
+		},
+		"403 in ignore range": {
+			statusCode:        403,
+			ignoreStatusCodes: [][]int{{400, 405}},
+			expectDrop:        true,
+		},
+		"200 not ignored": {
+			statusCode:        200,
+			ignoreStatusCodes: [][]int{{400, 405}},
+			expectDrop:        false,
+		},
+		"wrong code not ignored": {
+			statusCode:        "something",
+			ignoreStatusCodes: [][]int{{400, 405}},
+			expectDrop:        false,
+		},
+		"Single status code as single-element slice": {
+			statusCode:        404,
+			ignoreStatusCodes: [][]int{{404}},
+			expectDrop:        true,
+		},
+		"Single status code not in single-element slice": {
+			statusCode:        500,
+			ignoreStatusCodes: [][]int{{404}},
+			expectDrop:        false,
+		},
+		"Multiple single codes": {
+			statusCode:        500,
+			ignoreStatusCodes: [][]int{{404}, {500}},
+			expectDrop:        true,
+		},
+		"Multiple ranges - code in first range": {
+			statusCode:        404,
+			ignoreStatusCodes: [][]int{{400, 405}, {500, 599}},
+			expectDrop:        true,
+		},
+		"Multiple ranges - code in second range": {
+			statusCode:        500,
+			ignoreStatusCodes: [][]int{{400, 405}, {500, 599}},
+			expectDrop:        true,
+		},
+		"Multiple ranges - code not in any range": {
+			statusCode:        200,
+			ignoreStatusCodes: [][]int{{400, 405}, {500, 599}},
+			expectDrop:        false,
+		},
+		"Mixed single codes and ranges": {
+			statusCode:        404,
+			ignoreStatusCodes: [][]int{{404}, {500, 599}},
+			expectDrop:        true,
+		},
+		"Mixed single codes and ranges - code in range": {
+			statusCode:        500,
+			ignoreStatusCodes: [][]int{{404}, {500, 599}},
+			expectDrop:        true,
+		},
+		"Mixed single codes and ranges - code not matched": {
+			statusCode:        200,
+			ignoreStatusCodes: [][]int{{404}, {500, 599}},
+			expectDrop:        false,
+		},
+	}
+
+	for name, tt := range tests {
+		t.Run(name, func(t *testing.T) {
+			transport := &MockTransport{}
+			ctx := NewTestContext(ClientOptions{
+				EnableTracing:          true,
+				TracesSampleRate:       1.0,
+				Transport:              transport,
+				TraceIgnoreStatusCodes: tt.ignoreStatusCodes,
+			})
+
+			transaction := StartTransaction(ctx, "test")
+			// Simulate HTTP response data like the integrations do
+			transaction.SetData("http.response.status_code", tt.statusCode)
+			transaction.Finish()
+
+			dropped := transport.lastEvent == nil
+			if tt.expectDrop != dropped {
+				if tt.expectDrop {
+					t.Errorf("expected transaction with status code %d to be dropped", tt.statusCode)
+				} else {
+					t.Errorf("expected transaction with status code %d not to be dropped", tt.statusCode)
+				}
+			}
+		})
+	}
+}
+
 func TestSampleRate(t *testing.T) {
 	tests := []struct {
 		SampleRate float64

tracing.go

@@ -347,6 +347,58 @@ func (s *Span) SetDynamicSamplingContext(dsc DynamicSamplingContext) {
 	}
 }
 
+// shouldIgnoreStatusCode checks if the transaction should be ignored based on HTTP status code.
+func (s *Span) shouldIgnoreStatusCode() bool {
+	if !s.IsTransaction() {
+		return false
+	}
+
+	ignoreStatusCodes := s.clientOptions().TraceIgnoreStatusCodes
+	if len(ignoreStatusCodes) == 0 {
+		return false
+	}
+
+	s.mu.Lock()
+	statusCodeData, exists := s.Data["http.response.status_code"]
+	s.mu.Unlock()
+
+	if !exists {
+		return false
+	}
+
+	statusCode, ok := statusCodeData.(int)
+	if !ok {
+		return false
+	}
+
+	for _, ignoredRange := range ignoreStatusCodes {
+		switch len(ignoredRange) {
+		case 1:
+			// Single status code
+			if statusCode == ignoredRange[0] {
+				s.mu.Lock()
+				s.Sampled = SampledFalse
+				s.mu.Unlock()
+				DebugLogger.Printf("dropping transaction with status code %v: found in TraceIgnoreStatusCodes", statusCode)
+				return true
+			}
+		case 2:
+			// Range of status codes [min, max]
+			if ignoredRange[0] <= statusCode && statusCode <= ignoredRange[1] {
+				s.mu.Lock()
+				s.Sampled = SampledFalse
+				s.mu.Unlock()
+				DebugLogger.Printf("dropping transaction with status code %v: found in TraceIgnoreStatusCodes range [%d, %d]", statusCode, ignoredRange[0], ignoredRange[1])
+				return true
+			}
+		default:
+			DebugLogger.Printf("incorrect TraceIgnoreStatusCodes format: %v", ignoredRange)
+		}
+	}
+
+	return false
+}
+
 // doFinish runs the actual Span.Finish() logic.
 func (s *Span) doFinish() {
 	if s.EndTime.IsZero() {
@@ -360,6 +412,10 @@ func (s *Span) doFinish() {
 		}
 	}
 
+	if s.shouldIgnoreStatusCode() {
+		return
+	}
+
 	if !s.Sampled.Bool() {
 		return
 	}