#timeouts code explainers

java

public class TimedSocketReader {
 
    private static final int READ_TIMEOUT_MS = 5_000;
    private static final int CONNECT_TIMEOUT_MS = 3_000;

Reading a socket with connect and read timeouts

sockets timeouts io

Intermediate 8 steps

ruby

class WeatherLookup
  Result = Struct.new(:temperature, :conditions, keyword_init: true)
 
  class TimeoutError < StandardError; end

A resilient weather API service object in Rails

service-object http-client error-handling

Intermediate 7 steps

ruby

require "thread"
 
class ConnectionPool
  class TimeoutError < StandardError; end

Building a thread-safe connection pool in Ruby

concurrency resource-pooling mutex

Advanced 8 steps

java

public class TimedFetchService {
 
    private final ExecutorService executor = Executors.newFixedThreadPool(8);
    private final HttpClient httpClient = HttpClient.newHttpClient();

Enforcing HTTP timeouts with a Future

concurrency timeouts thread-pool

Intermediate 8 steps

python

from functools import wraps
import asyncio
 
from fastapi import APIRouter, FastAPI, Request

Per-route request timeouts in FastAPI

decorators async timeouts

Intermediate 6 steps

go

package middleware
 
import (
	"context"

A deadline-enforcing HTTP middleware in Go

middleware context goroutines

Advanced 7 steps

go

package proxy
 
import (
	"log"

Building a hardened Go reverse proxy

reverse-proxy http timeouts

Intermediate 7 steps

rust

use std::time::Duration;
 
use axum::{
    body::Body,

Turning Axum timeouts into 504 JSON

middleware timeouts error-handling

Intermediate 7 steps

javascript

const express = require('express');
const router = express.Router();
const { pool } = require('../db');
const redis = require('../redis');

Building a health check endpoint in Express

health-check timeouts promise-race

Intermediate 9 steps

typescript

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,

A per-route timeout interceptor in NestJS

interceptors metadata reflection rxjs

Intermediate 8 steps

rust

use std::time::Duration;
 
use axum::{
    extract::State,

Rate-limiting an expensive Axum route with tower

middleware concurrency-limiting shared-state

Intermediate 9 steps