Package ya context hutumika kwa nini?

Question

Accepted Answer

Package ya **`context`** hubeba **ishara za ufutaji, muda wa mwisho, na thamani zenye wigo wa ombi** kupitia mipaka ya API na goroutines. Ndiyo mbinu ya kawaida ya kudhibiti uhai wa operesheni — hasa kwa kufuta kazi na kueneza timeouts kupitia mnyororo wa wito wa function.

## Tatizo kuu inalolitatua

```text
A request starts work across many goroutines/functions (DB query, API call, etc.).
If the client disconnects or a timeout hits, you want to CANCEL all that work
so goroutines don't keep running uselessly (wasting resources / leaking).
→ context propagates the "stop now" signal down the entire call chain.
```

## Kuunda contexts

```go
ctx := context.Background()          // the root context (top of the tree)
ctx := context.TODO()                 // placeholder when unsure

// with a timeout — auto-cancels after the duration
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()                        // ALWAYS call cancel to release resources

// with manual cancellation
ctx, cancel := context.WithCancel(context.Background())
// call cancel() to signal cancellation

// with a deadline (specific time)
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Minute))
```

`WithTimeout`/`WithDeadline`/`WithCancel` hutoa context ya mtoto inayoweza kufutwa; lazima u-`defer cancel()` ili kuachilia rasilimali zake.

## Kuitikia ufutaji

```go
func doWork(ctx context.Context) error {
    for {
        select {
        case <-ctx.Done():            // fires when cancelled or timed out
            return ctx.Err()           // returns context.Canceled or DeadlineExceeded
        case work := <-jobs:
            process(work)
        }
    }
}
```

Functions hukagua `ctx.Done()` (channel inayofungwa wakati wa ufutaji) na husimama mara moja — hii ndiyo namna ufutaji unavyoenea kihalisi.

## Kupitisha context kupitia mnyororo wa wito (mkataba)

```go
// ctx is conventionally the FIRST parameter, named ctx
func handler(ctx context.Context, ...) {
    data, err := fetchFromDB(ctx, id)   // pass it down — DB call honors cancellation
}
func fetchFromDB(ctx context.Context, id int) (...) {
    row := db.QueryRowContext(ctx, ...)  // standard-library APIs accept context
}
```

Context hutiririka chini ya stack ya wito kama parameter ya kwanza, hivyo ufutaji hufikia kila tabaka (ikijumuisha wito wa DB/HTTP wa maktaba ya kawaida unaokubali context).

## Thamani zenye wigo wa ombi (tumia kwa uchache)

```go
ctx = context.WithValue(ctx, requestIDKey, "abc-123")   // attach a value
id := ctx.Value(requestIDKey)                            // retrieve it downstream
// ⚠️ for request-scoped metadata (request IDs, auth) — NOT for passing regular params
```

## Kwa nini ni muhimu

Package ya `context` ni ya msingi kwa kuandika services za Go imara, za daraja la uzalishaji — ndiyo njia ya kawaida, ya kiidiomatiki ya kushughulikia **ufutaji na timeouts** kupitia goroutines na mipaka ya API.

Thamani yake kuu ni kuzuia kazi iliyopotea na uvujaji wa rasilimali: wakati client anajitenga, muda wa mwisho unapita, au server inazima, context hueneza ishara ya ufutaji ili goroutines na operesheni zote zilizozaliwa kwa ombi hilo zisimame mara moja badala ya kuendesha bila maana (kinga muhimu dhidi ya uvujaji wa goroutine).

Ni iliyoenea katika Go halisi — HTTP servers, wito wa database, gRPC, na maktaba nyingi za mtandao hukubali `context.Context` kama parameter yao ya kwanza.

Kuelewa jinsi ya kuunda contexts (`WithTimeout`/`WithCancel`), kuitikia ufutaji (`<-ctx.Done()`), kanuni ya lazima-kuita-`cancel()`, na mkataba wa kupitisha context kupitia minyororo ya wito ni muhimu kwa kazi yoyote nzito ya backend ya Go na ni mada ya kawaida ya mahojiano.