Context Background in Go Services

The context.Background() function in Go creates an empty context without values, deadlines, or cancellation signals. This approach is almost "default" but while simple to use, can lead to significant issues in production systems, particularly around request tracing and resource management.

Lost Request Context

Here's a typical scenario where context.Background() breaks request tracing:

func ProcessData(data []byte) error {
    // Creates a new context, disconnected from request
    ctx := context.Background()

    // Any traced operations here lose connection
    // to the original request context
    result, err := someService.Process(ctx, data)
    if err != nil {
        return err
    }

    // Tracing tools can't connect this operation
    // back to the originating request
    return saveResult(ctx, result)
}

Instead, propagating the incoming request context maintains the tracing chain:

func ProcessData(ctx context.Context, data []byte) error {
    // Uses the request context with trace IDs
    result, err := someService.Process(ctx, data)
    if err != nil {
        return err
    }

    // Operations remain connected in tracing
    return saveResult(ctx, result)
}

Resource Management Issues

Background contexts also impact resource cleanup in goroutines:

func ProcessUserUploads(w http.ResponseWriter, r *http.Request) {
    // Wrong: creating new background context
    ctx := context.Background()

    file, _, err := r.FormFile("document")
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    defer file.Close()

    go func() {
        // This goroutine will keep running even if:
        // - Client disconnects
        // - Request times out
        // - Server starts shutdown
        for {
            select {
            case <-ctx.Done():
                return
            default:
                buf := make([]byte, 1024)
                _, err := file.Read(buf)
                if err == io.EOF {
                    return
                }
                // Process chunk, maybe upload to cloud storage
            }
        }
    }()

    w.WriteHeader(http.StatusAccepted)
}

With proper context propagation, resources get cleaned up when the parent request ends:

func ProcessUserUploads(w http.ResponseWriter, r *http.Request) {
    // Correct: use request's context
    ctx := r.Context()    // HTTP server manages this context lifecycle

    file, _, err := r.FormFile("document")
    if err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    defer file.Close()

    go func() {
        for {
            select {
            case <-ctx.Done():
                // Cleanup happens when:
                // - Client disconnects
                // - Request times out
                // - Parent context cancelled
                log.Printf("Upload processing cancelled: %v", ctx.Err())
                return
            default:
                buf := make([]byte, 1024)
                _, err := file.Read(buf)
                if err == io.EOF {
                    return
                }
                // Process chunk
            }
        }
    }()

    w.WriteHeader(http.StatusAccepted)
}

Valid Background Usage

Using context.Background() is valid for root-level operations such as application startup, daemon processes, or top-level dependency initialization—cases where there is no meaningful parent context to inherit.

func main() {
    // Appropriate use at program (or logical chain) root
    ctx := context.Background()

    // Add timeout for startup operations
    ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
    defer cancel()

    if err := initializeApp(ctx); err != nil {
        log.Fatal(err)
    }
}