Merge pull request #212 from fastly/cee-dub/request-meta

Use FastlyMeta for RequestID and SandboxID

Author: cee-dub

_examples/reusable-sessions/fastly.toml renamed to _examples/reusable-sandbox/fastly.toml

@@ -5,4 +5,4 @@ authors = ["[email protected]"]
 description = ""
 language = "go"
 manifest_version = 2
-name = "reusable-sessions"
+name = "reusable-sandbox"

_examples/reusable-sessions/main.go renamed to _examples/reusable-sandbox/main.go

@@ -5,17 +5,21 @@ package main
 import (
 	"context"
 	"fmt"
-	"os"
 	"time"
 
 	"github.com/fastly/compute-sdk-go/fsthttp"
 )
 
 func main() {
-	var requests int
+	var requestCount int
 	fsthttp.ServeMany(func(ctx context.Context, w fsthttp.ResponseWriter, r *fsthttp.Request) {
-		requests++
-		fmt.Fprintf(w, "Request %v, Hello, %s (%q, %q)!\n", requests, r.RemoteAddr, os.Getenv("FASTLY_TRACE_ID"), r.RequestID)
+		requestCount++
+		meta, err := r.FastlyMeta()
+		if err != nil {
+			fsthttp.Error(w, err.Error(), fsthttp.StatusInternalServerError)
+			return
+		}
+		fmt.Fprintf(w, "Request %v, Hello, %s (sandbox: %q, request: %q)!\n", requestCount, r.RemoteAddr, meta.SandboxID, meta.RequestID)
 	}, &fsthttp.ServeManyOptions{
 		NextTimeout: 1 * time.Second,
 		MaxRequests: 100,

compute/compute.go

@@ -16,8 +16,8 @@ import (
 // of the program.
 //
 // Because compute guests can run on a variety of different platforms,
-// you should not necessarily expect these values to converge across
-// different sessions. Instead, we strongly recommend using this value
+// you should not necessarily expect these raw values to converge across
+// different executions. Instead, we strongly recommend using this value
 // to look at the relative cost of various operations in your code base,
 // by taking the time before and after a particular operation and then
 // dividing this by the total amount of vCPU time your program takes.

end_to_end_tests/serve-many/main.go

@@ -5,7 +5,6 @@ package main
 import (
 	"context"
 	"fmt"
-	"os"
 	"time"
 
 	"github.com/fastly/compute-sdk-go/fsthttp"
@@ -19,17 +18,22 @@ func main() {
 	}
 
 	handler := func(ctx context.Context, w fsthttp.ResponseWriter, r *fsthttp.Request) {
-		if r.Header.Get("Close-Session") == "1" {
+		if r.Header.Get("Fresh-Sandbox") == "1" {
 			opts.Continue = func() bool {
 				return false
 			}
 		}
 
-		sessionID, requestID := os.Getenv("FASTLY_TRACE_ID"), r.RequestID
-		fmt.Printf("Session ID: %s, Request ID: %s\n", sessionID, requestID)
+		meta, err := r.FastlyMeta()
+		if err != nil {
+			fsthttp.Error(w, err.Error(), fsthttp.StatusInternalServerError)
+			return
+		}
+		sandboxID, requestID := meta.SandboxID, meta.RequestID
+		fmt.Printf("Sandbox ID: %s, Request ID: %s\n", sandboxID, requestID)
 
 		w.Header().Set("Content-Type", "text/plain")
-		w.Header().Set("Session-ID", sessionID)
+		w.Header().Set("Sandbox-ID", sandboxID)
 		w.Header().Set("Request-ID", requestID)
 		w.Write([]byte("OK"))
 	}

end_to_end_tests/serve-many/main_test.go

@@ -9,8 +9,8 @@ import (
 	"github.com/fastly/compute-sdk-go/fsthttp"
 )
 
-func TestSessionReuse(t *testing.T) {
-	// First request.  Session ID and request ID should match.
+func TestSandboxReuse(t *testing.T) {
+	// First request. Sandbox ID and request ID should match.
 	req, err := fsthttp.NewRequest("GET", "http://anyplace.horse", nil)
 	if err != nil {
 		t.Fatal(err)
@@ -21,44 +21,44 @@ func TestSessionReuse(t *testing.T) {
 	}
 	defer resp.Body.Close()
 
-	sessionID, requestID := resp.Header.Get("Session-ID"), resp.Header.Get("Request-ID")
+	sandboxID, requestID := resp.Header.Get("Sandbox-ID"), resp.Header.Get("Request-ID")
 
-	if sessionID == "" || requestID == "" {
-		t.Fatalf("Session-ID and/or Request-ID are empty: %s, %s", sessionID, requestID)
+	if sandboxID == "" || requestID == "" {
+		t.Fatalf("Sandbox-ID and/or Request-ID are empty: %s, %s", sandboxID, requestID)
 	}
-	if sessionID != requestID {
-		t.Errorf("sessionID = %s, requestID = %s; expected them to match", sessionID, requestID)
+	if sandboxID != requestID {
+		t.Errorf("sandboxID = %s, requestID = %s; expected them to match", sandboxID, requestID)
 	}
-	prevSessionID := sessionID
+	prevSandboxID := sandboxID
 
-	// Second request.  This should reuse the session, so the session ID
-	// should match the previous session ID and the request ID should
+	// Second request.  This should reuse the sandbox, so the sandbox ID
+	// should match the previous sandbox ID and the request ID should
 	// not match.
 	//
 	// We also set a header to tell the server to not allow any more
-	// requests on this session.
+	// requests on this sandbox.
 	req, err = fsthttp.NewRequest("GET", "http://anyplace.horse", nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	req.Header.Set("Close-Session", "1")
+	req.Header.Set("Fresh-Sandbox", "1")
 	resp, err = req.Send(context.Background(), "self")
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer resp.Body.Close()
 
-	sessionID, requestID = resp.Header.Get("Session-ID"), resp.Header.Get("Request-ID")
+	sandboxID, requestID = resp.Header.Get("Sandbox-ID"), resp.Header.Get("Request-ID")
 
-	if sessionID != prevSessionID {
-		t.Errorf("sessionID = %s, previous sessionID = %s; expected them to match", sessionID, sessionID)
+	if sandboxID != prevSandboxID {
+		t.Errorf("sandboxID = %s, previous sandboxID = %s; expected them to match", sandboxID, sandboxID)
 	}
-	if sessionID == requestID {
-		t.Errorf("sessionID = %s, requestID = %s; expected them to differ", sessionID, requestID)
+	if sandboxID == requestID {
+		t.Errorf("sandboxID = %s, requestID = %s; expected them to differ", sandboxID, requestID)
 	}
-	prevSessionID = sessionID
+	prevSandboxID = sandboxID
 
-	// Third request, we should have a new session ID and it should match the request ID
+	// Third request, we should have a new sandbox ID and it should match the request ID
 	req, err = fsthttp.NewRequest("GET", "http://anyplace.horse", nil)
 	if err != nil {
 		t.Fatal(err)
@@ -69,12 +69,12 @@ func TestSessionReuse(t *testing.T) {
 	}
 	defer resp.Body.Close()
 
-	sessionID, requestID = resp.Header.Get("Session-ID"), resp.Header.Get("Request-ID")
+	sandboxID, requestID = resp.Header.Get("Sandbox-ID"), resp.Header.Get("Request-ID")
 
-	if sessionID == prevSessionID {
-		t.Errorf("sessionID = %s, previous sessionID = %s; expected them to differ", sessionID, sessionID)
+	if sandboxID == prevSandboxID {
+		t.Errorf("sandboxID = %s, previous sandboxID = %s; expected them to differ", sandboxID, sandboxID)
 	}
-	if sessionID != requestID {
-		t.Errorf("sessionID = %s, requestID = %s; expected them to match", sessionID, requestID)
+	if sandboxID != requestID {
+		t.Errorf("sandboxID = %s, requestID = %s; expected them to match", sandboxID, requestID)
 	}
 }

fsthttp/backend.go

@@ -329,10 +329,10 @@ func (b *BackendOptions) ClientCertificate(certificate string, key secretstore.S
 
 // PoolConnections allows users to turn connection pooling on or off for the
 // backend. Pooling allows the Compute platform to reuse connections across
-// multiple sessions, resulting in lower resource use at the server (because it
-// does not need to reperform the TCP handhsake and TLS authentication when the
+// multiple executions, resulting in lower resource use at the server (because it
+// does not need to repeat the TCP handhsake and TLS authentication when the
 // connection is reused). The default is to pool connections. Set this to false
-// to create a new connection to the backend for every incoming session.
+// to create a new connection to the backend for every incoming request.
 func (b *BackendOptions) PoolConnections(poolingOn bool) *BackendOptions {
 	b.abiOpts.PoolConnections(poolingOn)
 	return b

fsthttp/request.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"io"
 	"net/url"
+	"os"
 	"strings"
 	"sync"
 	"time"
@@ -113,9 +114,6 @@ type Request struct {
 	// discarded.
 	ManualFramingMode bool
 
-	// RequestID is the current Fastly request ID
-	RequestID string
-
 	// ImageOptimizerOptions control the image optimizer request.
 	ImageOptimizerOptions *imageopto.Options
 
@@ -176,11 +174,6 @@ func newClientRequest(abiReq *fastly.HTTPRequest, abiReqBody *fastly.HTTPBody) (
 		return nil, fmt.Errorf("get protocol version: %w", err)
 	}
 
-	reqID, err := abiReq.DownstreamRequestID()
-	if err != nil {
-		return nil, fmt.Errorf("get request id: %w", err)
-	}
-
 	header := NewHeader()
 	keys := abiReq.GetHeaderNames()
 	for keys.Next() {
@@ -252,7 +245,6 @@ func newClientRequest(abiReq *fastly.HTTPRequest, abiReqBody *fastly.HTTPBody) (
 		RemoteAddr: remoteAddr.String(),
 		ServerAddr: serverAddr.String(),
 		TLSInfo:    tlsInfo,
-		RequestID:  reqID,
 		downstream: reqAbi{req: abiReq, body: abiReqBody},
 	}, nil
 }
@@ -371,8 +363,15 @@ func (req *Request) FastlyMeta() (*FastlyMeta, error) {
 	}
 
 	var err error
-
 	var fastlyMeta FastlyMeta
+
+	fastlyMeta.SandboxID = os.Getenv("FASTLY_TRACE_ID")
+
+	fastlyMeta.RequestID, err = req.downstream.req.DownstreamRequestID()
+	if err != nil {
+		return nil, fmt.Errorf("get request ID: %w", err)
+	}
+
 	fastlyMeta.H2, err = req.downstream.req.DownstreamH2Fingerprint()
 	if err = ignoreNoneError(err); err != nil {
 		return nil, fmt.Errorf("get H2 fingerprint: %w", err)
@@ -1076,6 +1075,12 @@ type TLSClientCertificateInfo struct {
 
 // FastlyMeta holds various Fastly-specific metadata for a request.
 type FastlyMeta struct {
+	// SandboxID is the unique identifier for the sandbox handling the request.
+	SandboxID string
+
+	// RequestID is the unique identifier for the request.
+	RequestID string
+
 	// H2 is the HTTP/2 fingerprint of a client request if available
 	H2 []byte
 

internal/abi/fastly/compute_runtime_guest.go

@@ -22,11 +22,11 @@ import (
 func fastlyGetVCPUMs(prim.Pointer[prim.U64]) FastlyStatus
 
 // Return the number of milliseconds spent on the CPU for the current
-// session.
+// sandbox.
 //
 // Because compute guests can run on a variety of different platforms,
-// you should not necessarily expect these values to converge across
-// different sessions. Instead, we strongly recommend using this value
+// you should not necessarily expect these raw values to converge across
+// different executions. Instead, we strongly recommend using this value
 // to look at the relative cost of various operations in your code base,
 // by taking the time before and after a particular operation and then
 // dividing this by the total amount of vCPU time your program takes.

secretstore/secretstore.go

@@ -115,7 +115,7 @@ func (s *Secret) Handle() *fastly.Secret {
 // This function is provided as a way to use data that should be secret,
 // but is being obtained by some other means than a Fastly Secret Store.
 // Secret values created this way are plaintext only, and are not shared
-// with other sessions.  This should only be used in situations in which
+// via a Store.  This should only be used in situations in which
 // an API requires a [Secret], but you cannot (for whatever reason) use
 // a [Store] to store them.
 //