[StackOverflow/go] Error: rpc error: code = Canceled desc = context canceled

### ROOT CAUSE The error "rpc error: code = Canceled desc = context canceled" occurs in gRPC when a context is canceled during an RPC call. This typically happens due to one of the following reasons: 1. **Client-Side Cancellation**: The client explicitly cancels the context before the RPC completes. 2. **Server-Side Cancellation**: The server cancels the context (e.g., due to a timeout or resource constraint). 3. **Network Issues**: The connection is dropped, causing the context to be canceled. 4. **Unhandled Context Cancellation**: The RPC method does not check the context for cancellation, leading to hangs or unhandled errors. ### CODE FIX To resolve this issue, ensure proper context handling in both the client and server code: #### Client-Side Fix: 1. **Use Context with Deadline**: Set a timeout to avoid long-running RPCs. ```go ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) defer cancel() // Ensure cleanup // Make RPC call resp, err := client.Method(ctx, args) if err != nil { // Handle error (e.g., log or retry) fmt.Printf("RPC failed: %v\n", err) } ``` 2. **Propagate Context to Child Goroutines**: Ensure worker goroutines check `ctx.Done()` periodically. ```go wg := sync.WaitGroup() for i := 0; i < 10; i++ { wg.Add(1) go func(ctx context.Context) { defer wg.Done() for { select { case <-ctx.Done(): fmt.Println("Child goroutine canceled") return default: // Work with RPC context } }(ctx) } wg.Wait() ``` #### Server-Side Fix: 1. **Check Context in Handlers**: Use `ctx` to control cancellations. ```go func (s *Server) Method(ctx context.Context, req *Request) (*Response, error) { select { case <-ctx.Done(): // Log or handle cancellation return nil, status.Errorf(codes.Canceled, "Request canceled") default: // Process request } return &Response{}, nil } ``` #### General Best Practices: - **Graceful Shutdown**: Use context cancellation for shutdown signals. ```go // Server shutdown shutdownCtx, cancel := context.WithCancel(context.Background()) go func() { // Wait for shutdown signal <-shutdownCtx.Done() // Cleanup resources }() ``` - **Avoid Blocking Calls**: Ensure RPC handlers don’t block indefinitely without checking `ctx.Done()`. By implementing these fixes, the application will handle context cancellations gracefully, preventing the "context canceled" error.