fsthttp: add stale-if-error logic

Author: dgryski

fsthttp/cache.go

@@ -159,24 +159,15 @@ const (
 	cacheStorageActionInvalid = 0xffff
 )
 
-func httpCacheWait(c *fastly.HTTPCacheHandle) error {
-	_, err := fastly.HTTPCacheGetState(c)
-	if err != nil {
-		return fmt.Errorf("get state: %w", err)
-	}
-	return nil
-}
-
-func httpCacheMustInsertOrUpdate(c *fastly.HTTPCacheHandle) (bool, error) {
+func httpCacheWait(c *fastly.HTTPCacheHandle) (fastly.CacheLookupState, error) {
 	state, err := fastly.HTTPCacheGetState(c)
 	if err != nil {
-		return false, fmt.Errorf("get state: %w", err)
-
+		return 0, fmt.Errorf("get state: %w", err)
 	}
-	return state&fastly.CacheLookupStateMustInsertOrUpdate == fastly.CacheLookupStateMustInsertOrUpdate, nil
+	return state, nil
 }
 
-func httpCacheGetFoundResponse(c *fastly.HTTPCacheHandle, req *Request, backend string, transformForClient bool) (*Response, error) {
+func httpCacheGetFoundResponse(c *fastly.HTTPCacheHandle, req *Request, backend string, transformForClient bool, wasHit bool) (*Response, error) {
 	abiResp, abiBody, err := fastly.HTTPCacheGetFoundResponse(c, transformForClient)
 	if err != nil {
 		if status, ok := fastly.IsFastlyError(err); ok && status == fastly.FastlyStatusNone {
@@ -185,9 +176,13 @@ func httpCacheGetFoundResponse(c *fastly.HTTPCacheHandle, req *Request, backend
 		return nil, fmt.Errorf("get found response: %w", err)
 	}
 
-	hits, err := fastly.HTTPCacheGetHits(c)
-	if err != nil {
-		return nil, fmt.Errorf("get hits: %w", err)
+	var hits uint64
+	if wasHit {
+		h, err := fastly.HTTPCacheGetHits(c)
+		if err != nil {
+			return nil, fmt.Errorf("get hits: %w", err)
+		}
+		hits = uint64(h)
 	}
 
 	var opts cacheWriteOptions
@@ -204,7 +199,7 @@ func httpCacheGetFoundResponse(c *fastly.HTTPCacheHandle, req *Request, backend
 	resp.cacheResponse = cacheResponse{
 		cacheWriteOptions: opts,
 		storageAction:     cacheStorageActionInvalid,
-		hits:              uint64(hits),
+		hits:              hits,
 	}
 	return resp, nil
 }
@@ -710,7 +705,7 @@ func (candidateResponse *CandidateResponse) applyAndStreamBack(req *Request) (*R
 		}
 		body.Close()
 
-		resp, err = httpCacheGetFoundResponse(readback, req, "", false)
+		resp, err = httpCacheGetFoundResponse(readback, req, "", false, true)
 		if err != nil {
 			return nil, fmt.Errorf("cache get found response: %w", err)
 		}
@@ -722,7 +717,7 @@ func (candidateResponse *CandidateResponse) applyAndStreamBack(req *Request) (*R
 		}
 		defer fastly.HTTPCacheTransactionClose(newch)
 
-		resp, err = httpCacheGetFoundResponse(newch, req, "", true)
+		resp, err = httpCacheGetFoundResponse(newch, req, "", true, true)
 		if err != nil {
 			return nil, fmt.Errorf("cache get found response: %w", err)
 		}

fsthttp/request.go

@@ -629,12 +629,13 @@ func (req *Request) sendWithGuestCache(ctx context.Context, backend string) (*Re
 			fastly.HTTPCacheTransactionClose(cacheHandle)
 		}
 	}()
-	if err := httpCacheWait(cacheHandle); err != nil {
+	state, err := httpCacheWait(cacheHandle)
+	if err != nil {
 		return nil, err
 	}
 
 	// is there a "usable" cached response (i.e. fresh or within SWR period)
-	resp, err := httpCacheGetFoundResponse(cacheHandle, req, backend, true)
+	resp, err := httpCacheGetFoundResponse(cacheHandle, req, backend, true, true)
 	if err != nil {
 		return nil, err
 	}
@@ -644,7 +645,7 @@ func (req *Request) sendWithGuestCache(ctx context.Context, backend string) (*Re
 
 		// if this is during SWR, we may be the "lucky winner" who is
 		// tasked with performing a background revalidation
-		if ok, _ := httpCacheMustInsertOrUpdate(cacheHandle); ok {
+		if state.Has(fastly.CacheLookupStateMustInsertOrUpdate) {
 			pending, err := req.sendAsyncForCaching(ctx, cacheHandle, backend)
 			if err != nil {
 				return nil, err
@@ -666,23 +667,42 @@ func (req *Request) sendWithGuestCache(ctx context.Context, backend string) (*Re
 			cacheHandle = nil
 		}
 
-		// Meanwhile, whether fresh or in SWR, we can immediately return
+		if state.Has(fastly.CacheLookupStateUsableIfError) {
+			// This is a stale-if-error response that is also USABLE, implying the request
+			// collapse has already happened.
+			// Mark the response's masked error as "error in request collapse leader".
+			resp.maskedError = ErrRequestCollapse
+		}
+
+		// Meanwhile, whether fresh or in SWR/SIE, we can immediately return
 		// the cached response:
 		resp.updateFastlyCacheHeaders(req)
 		return resp, nil
 	}
 
 	// no cached response
 
-	if ok, _ := httpCacheMustInsertOrUpdate(cacheHandle); ok {
-
+	if state.Has(fastly.CacheLookupStateMustInsertOrUpdate) {
 		pending, err := req.sendAsyncForCaching(ctx, cacheHandle, backend)
 		if err != nil {
 			return nil, err
 		}
 
 		candidateResp, err := newCandidateFromPendingBackendCaching(pending)
 		if err != nil {
+			if state.Has(fastly.CacheLookupStateUsableIfError) {
+				// Substitute stale-if-error response; let anyone else in the collapse know as
+				// well.
+				fastly.HTTPCacheTransactionChooseStale(cacheHandle)
+				resp, foundErr := httpCacheGetFoundResponse(cacheHandle, req, backend, true, false)
+				if foundErr != nil {
+					return nil, foundErr
+				}
+				resp.maskedError = err
+				resp.updateFastlyCacheHeaders(req)
+				return resp, nil
+			}
+
 			return nil, err
 		}
 

fsthttp/response.go

@@ -33,6 +33,10 @@ type Response struct {
 	// Body of the response.
 	Body io.ReadCloser
 
+	// If this response was served from the cache *and* the response was stale-if-error,
+	// this is the error from the revalidation attempt.
+	maskedError error
+
 	cacheResponse cacheResponse
 
 	abi struct {
@@ -71,6 +75,12 @@ func (resp *Response) RemoteAddr() (net.Addr, error) {
 	return &addr, nil
 }
 
+// If this response was served from the cache *and* the response was stale-if-error,
+// this is the error from the revalidation attempt.
+func (r *Response) MaskedError() error {
+	return r.maskedError
+}
+
 type netaddr struct {
 	ip   net.IP
 	port uint16

fsthttp/senderror.go

@@ -2,7 +2,11 @@
 
 package fsthttp
 
-import "github.com/fastly/compute-sdk-go/internal/abi/fastly"
+import (
+	"errors"
+
+	"github.com/fastly/compute-sdk-go/internal/abi/fastly"
+)
 
 // SendError provides detailed information about backend request failures.
 //
@@ -131,3 +135,7 @@ const (
 	// error.
 	SendErrorInternalError = fastly.SendErrorDetailTagInternalError
 )
+
+var (
+	ErrRequestCollapse = errors.New("error during request collapse")
+)

internal/abi/fastly/types.go

@@ -996,6 +996,10 @@ const (
 	CacheLookupStateCollapseError      CacheLookupState = 0b0010_0000 // $collapse_error
 )
 
+func (c CacheLookupState) Has(m CacheLookupState) bool {
+	return (c & m) == m
+}
+
 // witx:
 //
 //	(typename $purge_options_mask
@@ -1383,6 +1387,7 @@ const (
 	SendErrorDetailTagInternalError                     SendErrorDetailTag = 22
 	SendErrorDetailTagTLSAlertReceived                  SendErrorDetailTag = 23
 	SendErrorDetailTagTLSProtocolError                  SendErrorDetailTag = 24
+	SendErrorDetailTagH2Error                           SendErrorDetailTag = 25
 )
 
 // witx:
@@ -1406,6 +1411,7 @@ const (
 	sendErrorDetailMaskDNSErrorRCode = 1 << 1 // $dns_error_rcode
 	sendErrorDetailMaskDNSErrorInfo  = 1 << 2 // $dns_error_info_code
 	sendErrorDetailMaskTLSAlertID    = 1 << 3 // $tls_alert_id
+	sendErrorDetailMaskH2Error       = 1 << 4 // $h2_error
 )
 
 // witx:
@@ -1544,7 +1550,8 @@ func (d SendErrorDetail) String() string {
 		return fmt.Sprintf("TLS alert received (%s)", tlsAlertString(d.tlsAlertID))
 	case SendErrorDetailTagTLSProtocolError:
 		return "TLS protocol error"
-
+	case SendErrorDetailTagH2Error:
+		return "HTTP/2 error"
 	case SendErrorDetailTagUninitialized:
 		panic("should not be reached: SendErrorDetailTagUninitialized")
 	case SendErrorDetailTagOK: