Fix ContextCanceled: context canceled in Go

This error occurs when an operation's context is canceled, typically because the HTTP client disconnected, a parent context timed out, or cancel() was called explicitly. Fix it by checking for context cancellation errors and handling them gracefully instead of treating them as unexpected failures. Log at debug level for client disconnects.

Reading the Stack Trace

Here's what each line means:

• main.fetchData(0x14000226000) /app/services/data.go:28 +0x2d8: The fetchData function at line 28 encounters a canceled context, likely because the HTTP client disconnected.
• context.(*cancelCtx).Err(0x14000196040): The context's Err method returns Canceled, indicating the context was explicitly canceled by a parent.
• database/sql.(*DB).QueryContext(0x14000118300, {0x1029f0ea0, 0x14000196040}, {0x1028f1e60, 0x20}, {0x0, 0x0, 0x0}): The database query is canceled mid-flight because the context it depends on was canceled.

Common Causes

func fetchData(c *gin.Context) {
	rows, err := db.QueryContext(c.Request.Context(), longQuery)
	if err != nil {
		log.Printf("ERROR: %v", err) // logs client disconnects as errors
		c.JSON(500, gin.H{"error": "database error"})
		return
	}
}

func handler(w http.ResponseWriter, r *http.Request) {
	ctx, cancel := context.WithTimeout(r.Context(), 1*time.Second)
	cancel() // called immediately — all operations using ctx are canceled
	result, err := slowOperation(ctx)
}

func getData(ctx context.Context) ([]byte, error) {
	resp, err := http.Get(url) // does not use ctx
	if err != nil {
		return nil, err // could be context.Canceled — not checked
	}
	return io.ReadAll(resp.Body)
}

The Fix

Check for context.Canceled and context.DeadlineExceeded separately. Client disconnects (Canceled) should be logged at debug level and not trigger error alerts. Deadline exceeded should return 504. Only log unexpected database errors as errors.

func fetchData(c *gin.Context) {
	rows, err := db.QueryContext(c.Request.Context(), longQuery)
	if err != nil {
		log.Printf("ERROR: %v", err)
		c.JSON(500, gin.H{"error": "database error"})
		return
	}
	defer rows.Close()
	// process rows...
}

func fetchData(c *gin.Context) {
	rows, err := db.QueryContext(c.Request.Context(), longQuery)
	if err != nil {
		if errors.Is(err, context.Canceled) {
			log.Printf("DEBUG: client disconnected during query")
			return // client is gone, no response needed
		}
		if errors.Is(err, context.DeadlineExceeded) {
			c.JSON(http.StatusGatewayTimeout, gin.H{"error": "query timed out"})
			return
		}
		log.Printf("ERROR: database query failed: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "database error"})
		return
	}
	defer rows.Close()
	// process rows...
}

Testing the Fix

package services_test

import (
	"context"
	"testing"

	"github.com/DATA-DOG/go-sqlmock"
	"github.com/stretchr/testify/assert"
)

func TestFetchData_ContextCanceled(t *testing.T) {
	db, mock, _ := sqlmock.New()
	defer db.Close()

	mock.ExpectQuery("SELECT").WillReturnError(context.Canceled)

	ctx, cancel := context.WithCancel(context.Background())
	cancel()

	_, err := fetchDataWithContext(ctx, db)
	assert.ErrorIs(t, err, context.Canceled)
}

func TestFetchData_DeadlineExceeded(t *testing.T) {
	db, mock, _ := sqlmock.New()
	defer db.Close()

	mock.ExpectQuery("SELECT").WillReturnError(context.DeadlineExceeded)

	_, err := fetchDataWithContext(context.Background(), db)
	assert.ErrorIs(t, err, context.DeadlineExceeded)
}

func TestFetchData_Success(t *testing.T) {
	db, mock, _ := sqlmock.New()
	defer db.Close()

	rows := sqlmock.NewRows([]string{"id"}).AddRow(1)
	mock.ExpectQuery("SELECT").WillReturnRows(rows)

	result, err := fetchDataWithContext(context.Background(), db)
	assert.NoError(t, err)
	assert.NotNil(t, result)
}

Run your tests:

go test ./services/... -v

Pushing Through CI/CD

git checkout -b fix/go-context-canceled,git add services/data.go services/data_test.go,git commit -m "fix: distinguish context cancellation from database errors",git push origin fix/go-context-canceled

Your CI config should look something like this:

name: CI
on:
  pull_request:
    branches: [main]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v5
        with:
          go-version: '1.22'
      - run: go mod download
      - run: go vet ./...
      - run: go test ./... -race -coverprofile=coverage.out
      - run: go build ./...

The Full Manual Process: 18 Steps

Here's every step you just went through to fix this one bug:

1. Notice the error alert or see it in your monitoring tool
2. Open the error dashboard and read the stack trace
3. Identify the file and line number from the stack trace
4. Open your IDE and navigate to the file
5. Read the surrounding code to understand context
6. Reproduce the error locally
7. Identify the root cause
8. Write the fix
9. Run the test suite locally
10. Fix any failing tests
11. Write new tests covering the edge case
12. Run the full test suite again
13. Create a new git branch
14. Commit and push your changes
15. Open a pull request
16. Wait for code review
17. Merge and deploy to production
18. Monitor production to confirm the error is resolved

Total time: 30-60 minutes. For one bug.

go get github.com/bugstack/sdk

import "github.com/bugstack/sdk"

func init() {
  bugstack.Init(os.Getenv("BUGSTACK_API_KEY"))
}

Deploying the Fix (Manual Path)

1. Run go test ./... locally to confirm context handling works.
2. Open a pull request with the context error handling changes.
3. Wait for CI checks to pass on the PR.
4. Have a teammate review and approve the PR.
5. Merge to main and verify in staging.

Frequently Asked Questions