This repository is the official gRPC implementation for .NET (grpc-dotnet), providing a comprehensive set of libraries for building gRPC services and clients on ASP.NET Core. It includes server-side integration via `Grpc.AspNetCore.Server` with full support for unary, server-streaming, client-streaming, and duplex streaming calls, as well as client-side libraries (`Grpc.Net.Client`, `Grpc.Net.ClientFactory`) that leverage `HttpClient` and DI. The codebase also covers gRPC-Web (both server middleware and client handler), health checks, server reflection, load balancing, retry/hedging policies, compression, interceptors, and a CLI tool (`dotnet-grpc`) for managing protobuf references. The architecture is modular, with clear separation of concerns: core abstractions in `Grpc.Core.Api`, shared utilities in `Grpc.Net.Common`, and platform-specific implementations. Extensive unit and functional tests, performance benchmarks, and interop test assets ensure correctness and performance across .NET versions and platforms.
Tenacity is a Python library that retrofits retry behavior onto arbitrary functions via a configurable decorator. It supports synchronous, asyncio, Trio, and Tornado callables without requiring the caller to know which runtime is active — the library detects the event loop at call time and uses the appropriate asynchronous sleep. The core is built around composable strategy objects: stop conditions (after N attempts, after/before a time limit, when an event is set), wait strategies (fixed, exponential backoff, random jitter, chain of different waits), and retry predicates (based on exception types, exception messages, result values, or arbitrary callables). Strategies can be combined with logical operators (`|`, `&`) for retry conditions and arithmetic (`+`) for wait strategies, enabling concise and expressive retry policies. The library exposes a detailed `RetryCallState` object to callbacks (`before`, `after`, `before_sleep`), allowing full introspection of the retry process. Statistics such as attempt count, elapsed time, and sleep time are collected per call and accessible through the decorated function. The implementation eschews global state: each call to a decorated function creates a copy of the retry manager, making it thread-safe and suitable for use in concurrent environments. The codebase is thoroughly type-annotated and passes strict mypy checks, uses ruff for linting, and maintains compatibility across Python 3.10 through 3.15.
Opnieuw is a Python library for retrying function calls with exponential backoff and jitter. It provides a clean, opinionated decorator API that requires only two parameters: maximum total calls and a retry window. The library handles both synchronous and asynchronous functions, supports exception chaining, and offers context managers to override retry behavior (e.g., disable retries or skip waits during testing). The core design uses a `BackoffCalculator` class that computes backoff intervals using a geometric series, and a `Clock` abstraction to allow time manipulation in tests. The library is small, fully typed, and demonstrates strong software craftsmanship with proper use of context variables for thread/async safety.
This repository is `imroc/req`, a feature-rich, production-grade HTTP client library for Go (version 3). It provides a high-level fluent API for building and executing HTTP requests with support for HTTP/1.1, HTTP/2, and HTTP/3 (via QUIC). Key capabilities include connection pooling, automatic retries with configurable backoff, redirect policies, request/response middleware, TLS fingerprint impersonation (mimicking Chrome, Firefox, Safari), SOCKS4/4a/5 proxying, compression (gzip, deflate, brotli, zstd), response body auto-decode (charset detection), file upload/download with progress callbacks, parallel downloading, and extensive debugging via request/response dump and trace. The library is built on top of Go's `net/http` transport but extends it significantly with custom implementations for HTTP/2 frames, HTTP/3, and SOCKS. It is designed for both simple API calls and complex integrations, as demonstrated by included examples for OpenTelemetry tracing and GitHub API usage. The codebase is well-tested and actively maintained, targeting recent Go versions (1.25+). While primarily an HTTP client library, it includes self-contained utility packages for charset detection, SOCKS proxy, and compression that could be reused independently.
lua-resty-logger-socket is a Lua library for Nginx (using ngx_lua) that provides nonblocking remote logging. It buffers log messages in memory and sends them to a remote log server (via TCP, UDP, or Unix domain socket) when the buffer reaches a configurable size or when manually flushed. The library implements efficient buffering with two-level buffers to minimize string concatenation, buffer reuse to prevent memory leaks, retry logic for connection and send failures, periodic flushing, and graceful handling of Nginx worker shutdown to flush remaining logs. It supports SSL with SNI and certificate verification.
Methanol is an extensible HTTP client library built on Java's java.net.http package. It provides core HTTP functionality enhanced with features like automatic decompression (gzip, deflate, Brotli), pluggable body adapters for JSON/XML/Protobuf, HTTP caching with multiple backends (memory, disk, Redis), request/response interceptors, retry mechanisms, progress tracking, and Kotlin DSL support. The library follows a modular architecture with separate modules for core functionality, format adapters, extensions, and testing. Key entry points include Methanol.Builder for client creation, MutableRequest for request building, and BodyAdapter for encoding/decoding. Data flows involve request interception, body encoding, HTTP exchange via java.net.http, response interception, body decoding, and optional caching/progress tracking. External dependencies vary by module: core requires only JDK 11+, while adapters depend on libraries like Jackson/Gson/Moshi, extensions on Redis Lettuce or native Brotli, and testing on JUnit5/MockWebServer.
Outpost is a production-grade, multi-tenant event delivery platform by Hookdeck. It ingests events via an HTTP API or message queue adapters (RabbitMQ, AWS SQS, GCP PubSub, Azure Service Bus), routes them to configurable destinations (webhooks, AWS S3/SQS/Kinesis, Azure Service Bus, GCP PubSub, Kafka, RabbitMQ, Hookdeck), and provides end-to-end observability including delivery logs, metrics, alerting, and a self-service user portal. The system is implemented as a modular Go monolith with pluggable storage drivers (PostgreSQL, ClickHouse, Redis) and a clean provider pattern for destination types. It includes generated SDKs for Go, Python, and TypeScript (via Speakeasy), plus a React-based embedded portal. The codebase demonstrates strong engineering practices: abstract backends with conformance test suites, cursor-based pagination, configurable backoff strategies, distributed locking, and comprehensive integration tests covering all destination types. Notable reusable components include a generic LRU cache with TTL, a JSON filter matcher, a cursor pagination library, and an ID generation utility.
The httr package is an R library for making HTTP requests. It provides functions for the main HTTP verbs (GET, POST, PUT, DELETE, PATCH, HEAD) and a generic VERB function for custom verbs. It includes comprehensive support for HTTP configuration (authentication, headers, cookies, proxies, timeouts, etc.) and OAuth 1.0 and 2.0 authentication. Responses are captured in a response object and can be accessed as raw bytes, text, or parsed into common formats (JSON, XML, HTML, etc.). The package also includes utilities for URL parsing and building, media type parsing, HTTP date handling, retry logic with exponential backoff, and HTTP caching. Note: This package is superseded by httr2 for new development, but is still maintained for CRAN compatibility.