rename from jttp to gttp

Author: jcalabro

README.md

@@ -1,11 +1,11 @@
-# jttp
+# gttp
 
-[![ci](https://github.com/jcalabro/jttp/actions/workflows/ci.yaml/badge.svg)](https://github.com/jcalabro/jttp/actions/workflows/ci.yaml)
-[![Go Reference](https://pkg.go.dev/badge/github.com/jcalabro/jttp.svg)](https://pkg.go.dev/github.com/jcalabro/jttp)
+[![ci](https://github.com/bluesky-social/gttp/actions/workflows/ci.yaml/badge.svg)](https://github.com/bluesky-social/gttp/actions/workflows/ci.yaml)
+[![Go Reference](https://pkg.go.dev/badge/github.com/bluesky-social/gttp.svg)](https://pkg.go.dev/github.com/bluesky-social/gttp)
 
-A robust HTTP client for Go with good defaults and tunable behavior.
+A robust HTTP client for Go with good defaults and tunable behavior. Called `gttp` because it's a "go http" client library.
 
-`jttp.New()` returns a standard `*http.Client` with sensible timeouts,
+`gttp.New()` returns a standard `*http.Client` with sensible timeouts,
 connection pooling, retry logic, and safety guards built in.
 
 ## Features
@@ -25,17 +25,17 @@ connection pooling, retry logic, and safety guards built in.
 
 ```go
 // Use the defaults:
-client := jttp.New()
+client := gttp.New()
 resp, err := client.Get("https://example.com")
 
 // Tune for your environment:
-client := jttp.New(
-    jttp.WithTimeout(10 * time.Second),
-    jttp.WithRetries(5),
-    jttp.WithIdleTimeout(10 * time.Second),
-    jttp.WithMaxResponseBodyBytes(100 << 20),
-    jttp.WithStrictSSRFProtection(),
+client := gttp.New(
+    gttp.WithTimeout(10 * time.Second),
+    gttp.WithRetries(5),
+    gttp.WithIdleTimeout(10 * time.Second),
+    gttp.WithMaxResponseBodyBytes(100 << 20),
+    gttp.WithStrictSSRFProtection(),
 )
 ```
 
-See [godoc](https://pkg.go.dev/github.com/jcalabro/jttp) for the full option list.
+See [godoc](https://pkg.go.dev/github.com/bluesky-social/gttp) for the full option list.

errors.go

@@ -1,61 +1,61 @@
-package jttp
+package gttp
 
 import "errors"
 
-// Sentinel errors returned by jttp. Callers can use errors.Is to distinguish
+// Sentinel errors returned by gttp. Callers can use errors.Is to distinguish
 // them. All are wrapped with %w when returned, so the underlying cause (if
 // any) remains reachable via errors.Unwrap / errors.As / errors.AsType.
 var (
 	// ErrBodyTooLarge is returned when a request body exceeds the retry
 	// buffer limit (see WithMaxRetryBodyBytes) and the body does not
 	// already provide a GetBody function for rewinding.
-	ErrBodyTooLarge = errors.New("jttp: request body exceeds retry buffer limit")
+	ErrBodyTooLarge = errors.New("gttp: request body exceeds retry buffer limit")
 
 	// ErrBodyRead is returned when reading the request body into the retry
 	// buffer fails.
-	ErrBodyRead = errors.New("jttp: reading request body for retry")
+	ErrBodyRead = errors.New("gttp: reading request body for retry")
 
 	// ErrBodyClose is returned when closing the original request body (after
 	// buffering it for retry) fails.
-	ErrBodyClose = errors.New("jttp: closing request body")
+	ErrBodyClose = errors.New("gttp: closing request body")
 
 	// ErrBodyRewind is returned when rewinding the request body between
 	// retry attempts fails (req.GetBody returned an error).
-	ErrBodyRewind = errors.New("jttp: rewinding request body")
+	ErrBodyRewind = errors.New("gttp: rewinding request body")
 
 	// ErrTooManyRedirects is returned when the redirect chain exceeds the
 	// configured maximum (see WithRedirectPolicy).
-	ErrTooManyRedirects = errors.New("jttp: too many redirects")
+	ErrTooManyRedirects = errors.New("gttp: too many redirects")
 
 	// ErrBodyIdleTimeout is returned when a response body read or a request
 	// body write stalls for longer than the configured idle timeout
 	// (see WithIdleTimeout).
-	ErrBodyIdleTimeout = errors.New("jttp: body idle timeout")
+	ErrBodyIdleTimeout = errors.New("gttp: body idle timeout")
 
 	// ErrBodyTransferTooSlow is returned when the rolling average transfer
 	// rate of the response body falls below the configured floor
 	// (see WithMinTransferRate).
-	ErrBodyTransferTooSlow = errors.New("jttp: body transfer rate below minimum")
+	ErrBodyTransferTooSlow = errors.New("gttp: body transfer rate below minimum")
 
 	// ErrResponseTooLarge is returned when the decompressed response body
 	// exceeds the configured maximum size (see WithMaxResponseBodyBytes).
-	ErrResponseTooLarge = errors.New("jttp: response body exceeds max size")
+	ErrResponseTooLarge = errors.New("gttp: response body exceeds max size")
 
 	// ErrDecompressionBomb is returned when the ratio of decompressed to
 	// compressed bytes exceeds the configured maximum
 	// (see WithMaxCompressionRatio).
-	ErrDecompressionBomb = errors.New("jttp: decompression ratio exceeded")
+	ErrDecompressionBomb = errors.New("gttp: decompression ratio exceeded")
 
 	// ErrRedirectLoop is returned when a redirect would revisit a URL
 	// already seen in the current chain.
-	ErrRedirectLoop = errors.New("jttp: redirect loop detected")
+	ErrRedirectLoop = errors.New("gttp: redirect loop detected")
 
 	// ErrSchemeDowngrade is returned when a redirect would move from https
 	// to http without WithAllowSchemeDowngrade.
-	ErrSchemeDowngrade = errors.New("jttp: redirect downgrades scheme https to http")
+	ErrSchemeDowngrade = errors.New("gttp: redirect downgrades scheme https to http")
 
 	// ErrBlockedByIPPolicy is returned when a redirect target's resolved IP
 	// falls within one of the default-blocked ranges (private, loopback,
 	// link-local, multicast, unique-local v6, CGNAT, NAT64, or IMDS addresses).
-	ErrBlockedByIPPolicy = errors.New("jttp: target resolves to blocked IP range")
+	ErrBlockedByIPPolicy = errors.New("gttp: target resolves to blocked IP range")
 )

errors_test.go

@@ -1,4 +1,4 @@
-package jttp
+package gttp
 
 import (
 	"context"
@@ -107,3 +107,24 @@ func TestTier1SentinelsDefined(t *testing.T) {
 		}
 	}
 }
+
+func TestSentinelErrorPrefix(t *testing.T) {
+	for _, err := range []error{
+		ErrBodyTooLarge,
+		ErrBodyRead,
+		ErrBodyClose,
+		ErrBodyRewind,
+		ErrTooManyRedirects,
+		ErrBodyIdleTimeout,
+		ErrBodyTransferTooSlow,
+		ErrResponseTooLarge,
+		ErrDecompressionBomb,
+		ErrRedirectLoop,
+		ErrSchemeDowngrade,
+		ErrBlockedByIPPolicy,
+	} {
+		if !strings.HasPrefix(err.Error(), "gttp: ") {
+			t.Errorf("sentinel error %q does not have gttp prefix", err)
+		}
+	}
+}

gate_test.go

@@ -1,4 +1,4 @@
-package jttp
+package gttp
 
 import (
 	"context"

go.mod

@@ -1,4 +1,4 @@
-module github.com/jcalabro/jttp
+module github.com/bluesky-social/gttp
 
 go 1.26
 

jttp.go gttp.gojttp.go renamed to gttp.go

@@ -1,4 +1,4 @@
-// Package jttp provides a robust HTTP client with reasonable defaults and
+// Package gttp provides a robust HTTP client with reasonable defaults and
 // tunable behavior.
 //
 // The returned *http.Client is fully standard — callers use client.Do,
@@ -17,17 +17,17 @@
 //
 // Basic usage:
 //
-//	client := jttp.New() // be sure to reuse this single object across multiple requests!
+//	client := gttp.New() // be sure to reuse this single object across multiple requests!
 //	resp, err := client.Get("https://example.com")
 //
 // With options:
 //
-//	client := jttp.New(
-//	    jttp.WithTimeout(10 * time.Second),
-//	    jttp.WithRetries(5),
-//	    jttp.WithAdditionalRetryableStatusCodes(500),
+//	client := gttp.New(
+//	    gttp.WithTimeout(10 * time.Second),
+//	    gttp.WithRetries(5),
+//	    gttp.WithAdditionalRetryableStatusCodes(500),
 //	)
-package jttp
+package gttp
 
 import (
 	"context"
@@ -288,13 +288,13 @@ func New(opts ...Option) *http.Client {
 			var err error
 			h2, err = configureHTTP2(tr, cfg.http2ReadIdleTimeout, cfg.http2PingTimeout)
 			if err != nil {
-				panic(fmt.Sprintf("jttp: unexpected error configuring HTTP/2: %v", err))
+				panic(fmt.Sprintf("gttp: unexpected error configuring HTTP/2: %v", err))
 			}
 		}
 		base = tr
 	}
 
-	// Only a jttp-owned, direct transport can guarantee that the address
+	// Only a gttp-owned, direct transport can guarantee that the address
 	// validated by the IP policy is the address actually dialed. Custom
 	// transports and proxies retain the existing request-time checks.
 	ipPolicyAtDial := cfg.strictSSRFInitial && cfg.transport == nil && cfg.disableProxy && !cfg.allowPrivateRedirects
@@ -458,7 +458,7 @@ func WithRetryableStatusCodes(codes ...int) Option {
 // WithAdditionalRetryableStatusCodes adds status codes to the default retryable set
 // without replacing it. For example, to also retry on 500:
 //
-//	jttp.New(jttp.WithAdditionalRetryableStatusCodes(500))
+//	gttp.New(gttp.WithAdditionalRetryableStatusCodes(500))
 func WithAdditionalRetryableStatusCodes(codes ...int) Option {
 	return func(c *config) {
 		for _, code := range codes {
@@ -481,7 +481,7 @@ func WithRetryableMethods(methods ...string) Option {
 // WithAdditionalRetryableMethods adds HTTP methods to the default retryable set
 // without replacing it. For example, to also retry POST and PUT:
 //
-//	jttp.New(jttp.WithAdditionalRetryableMethods("POST", "PUT"))
+//	gttp.New(gttp.WithAdditionalRetryableMethods("POST", "PUT"))
 func WithAdditionalRetryableMethods(methods ...string) Option {
 	return func(c *config) {
 		for _, m := range methods {
@@ -530,11 +530,11 @@ func WithRetryObserver(fn func(attempt int, req *http.Request, resp *http.Respon
 // timeout, size cap, min-rate) are still applied on top, but note:
 //
 // The decompression-bomb guard (WithMaxCompressionRatio) is effectively
-// disabled when a custom transport is supplied, because jttp can no longer
+// disabled when a custom transport is supplied, because gttp can no longer
 // control the base transport's DisableCompression setting. The caller's
 // transport is presumed to handle Accept-Encoding / gzip decoding itself,
 // and once stdlib's default transport auto-decodes, the response arrives
-// without a Content-Encoding header for jttp to act on. If you need the
+// without a Content-Encoding header for gttp to act on. If you need the
 // bomb guard, use the default transport.
 func WithTransport(rt http.RoundTripper) Option {
 	return func(c *config) { c.transport = rt }
@@ -609,7 +609,7 @@ func WithDialKeepAlive(d time.Duration) Option {
 //
 // WithResolver is likewise ignored in the general case, but not in strict
 // direct mode: when WithStrictSSRFProtection and WithNoProxy are set without
-// WithAllowPrivateRedirects, jttp resolves the request hostname itself with the
+// WithAllowPrivateRedirects, gttp resolves the request hostname itself with the
 // configured resolver, validates the full answer set, and calls this function
 // only with an already-validated literal IP address. In that mode WithResolver
 // controls the validation lookup, and a custom dialer that performs its own
@@ -625,7 +625,7 @@ func WithDialContext(fn func(ctx context.Context, network, address string) (net.
 // This is useful for directing DNS queries to a specific server (e.g., 1.1.1.1)
 // without replacing the entire dial function. Example:
 //
-//	jttp.New(jttp.WithResolver(&net.Resolver{
+//	gttp.New(gttp.WithResolver(&net.Resolver{
 //	    PreferGo: true,
 //	    Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
 //	        return (&net.Dialer{}).DialContext(ctx, "udp", "1.1.1.1:53")
@@ -716,9 +716,9 @@ func WithAllowPrivateRedirects() Option {
 // attacker-controlled URLs.
 //
 // Combine this with [WithNoProxy] to bind validation to the actual network
-// connection: jttp resolves each hostname once per new connection, validates
+// connection: gttp resolves each hostname once per new connection, validates
 // every returned address, and dials an approved literal address. With a proxy
-// or custom transport, jttp cannot control the target dial and therefore
+// or custom transport, gttp cannot control the target dial and therefore
 // retains request-time DNS preflight checks instead. The preflight path is
 // also retained with [WithAllowPrivateRedirects], whose redirect-specific
 // exception cannot be represented safely by a connection-wide dial policy.

jttp_test.go gttp_test.gojttp_test.go renamed to gttp_test.go

@@ -1,4 +1,4 @@
-package jttp
+package gttp
 
 import (
 	"bytes"

guard.go

@@ -1,4 +1,4 @@
-package jttp
+package gttp
 
 import (
 	"context"
@@ -135,7 +135,7 @@ func newGuardedBody(inner io.ReadCloser, cfg guardedBodyConfig) (*guardedBody, e
 		g.compressed = &countingReader{r: inner}
 		gz, err := gzip.NewReader(g.compressed)
 		if err != nil {
-			return nil, fmt.Errorf("jttp: gzip.NewReader: %w", err)
+			return nil, fmt.Errorf("gttp: gzip.NewReader: %w", err)
 		}
 		g.gz = gz
 	}
@@ -213,7 +213,7 @@ func (g *guardedBody) Close() error {
 }
 
 // ctxErr returns the context's cancellation cause if the context is done,
-// otherwise nil. If the cause is a jttp sentinel it is returned unwrapped so
+// otherwise nil. If the cause is a gttp sentinel it is returned unwrapped so
 // errors.Is works naturally at the call site.
 func (g *guardedBody) ctxErr() error {
 	if g.cfg.ctx == nil {

guard_test.go

@@ -1,4 +1,4 @@
-package jttp
+package gttp
 
 import (
 	"bytes"

http2.go

@@ -1,4 +1,4 @@
-package jttp
+package gttp
 
 import (
 	"net/http"