Tracing request failed (context timed out)

[weeco]

I'm facing the following error logs:

time=2025-08-25T11:21:32.053+01:00 level=WARN msg="[non-fatal] Tracing: request failed" error="Post \"https://api.openai.com/v1/traces/ingest\": context canceled"
time=2025-08-25T11:21:33.121+01:00 level=WARN msg="[non-fatal] Tracing: request failed" error="Post \"https://api.openai.com/v1/traces/ingest\": context canceled"
time=2025-08-25T11:21:35.149+01:00 level=WARN msg="[non-fatal] Tracing: request failed" error="Post \"https://api.openai.com/v1/traces/ingest\": context canceled"

I start an agent as part of an HTTP request, the agent finishes and returns the response (using a stream). It seems even when passing a background context into agents.RunStreamedChan(context.Background(), agent, userRequest) this is still happening. So I'm wondering where the context for the tracing client is coming from and how I can fix this (I don't want to disable traces)?

NIT: I guess we don't have to retry if context was cancelled on the first attempt already.

[matteo-grella]

Hi @weeco -could you provide a minimal reproducible example?

[weeco]

Sorry for the delay. Here's an example. Some portions of the code are irrelevant but they shouldn't distract you anyways:

Start with:

go run main.go

And then curl to trigger the issue:

curl http://localhost:8080/stream-agent

Logs should be:

2025/08/29 13:21:56 Server starting on :8080
2025/08/29 13:21:56 Test with: curl http://localhost:8080/stream-agent
time=2025-08-29T13:21:58.630+01:00 level=INFO msg="Starting agent stream request"
time=2025-08-29T13:22:08.988+01:00 level=INFO msg="Agent stream completed"
time=2025-08-29T13:22:13.407+01:00 level=WARN msg="[non-fatal] Tracing: request failed" error="Post \"https://api.openai.com/v1/traces/ingest\": context canceled"
time=2025-08-29T13:22:14.449+01:00 level=WARN msg="[non-fatal] Tracing: request failed" error="Post \"https://api.openai.com/v1/traces/ingest\": context canceled"
time=2025-08-29T13:22:16.521+01:00 level=WARN msg="[non-fatal] Tracing: request failed" error="Post \"https://api.openai.com/v1/traces/ingest\": context canceled"
time=2025-08-29T13:22:16.521+01:00 level=ERROR msg="[non-fatal] Tracing: max retries reached, giving up on this batch."

My suspicion is that the context of the request is also used for emitting the traces. But this doesn't really make sense since the trace is emitted after the agent run (separately). I do want to use the request context for the agent - but not for the trace. Reason being: If a user is no longer waiting for the agent I want to cancel the agent run.

package main

import (
	"fmt"
	"log"
	"log/slog"
	"net/http"
	"os"

	"github.com/nlpodyssey/openai-agents-go/agents"
	"github.com/nlpodyssey/openai-agents-go/modelsettings"
	"github.com/nlpodyssey/openai-agents-go/usage"
	"github.com/openai/openai-go/v2"
)

func main() {
	// Get OpenAI API key from environment
	apiKey := os.Getenv("OPENAI_API_KEY")
	if apiKey == "" {
		log.Fatal("OPENAI_API_KEY environment variable is required")
	}

	// Start HTTP server
	http.HandleFunc("/stream-agent", streamAgentHandler)
	log.Println("Server starting on :8080")
	log.Println("Test with: curl http://localhost:8080/stream-agent")
	log.Fatal(http.ListenAndServe(":8080", nil))
}

func streamAgentHandler(w http.ResponseWriter, r *http.Request) {
	// Set headers for streaming
	w.Header().Set("Content-Type", "text/plain")
	w.Header().Set("Cache-Control", "no-cache")
	w.Header().Set("Connection", "keep-alive")

	// Get request context
	ctx := r.Context()
	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug}))

	logger.InfoContext(ctx, "Starting agent stream request")

	// Create agent with tracing
	agent := agents.New("Test Agent").
		WithInstructions("You are a helpful assistant. Respond with a short message.").
		WithModel("gpt-5").
		WithModelSettings(modelsettings.ModelSettings{
			// Note: Summary MUST be specified or reasoning tokens won't be emitted.
			Reasoning: openai.ReasoningParam{
				Effort:  openai.ReasoningEffortMedium,
				Summary: openai.ReasoningSummaryAuto,
			},
		})

	// Create usage tracker
	usageTracker := usage.NewUsage()
	ctx = usage.NewContext(ctx, usageTracker)

	// Start agent processing
	userRequest := "Say hello and explain what you are"
	eventsCh, errCh, err := agents.RunStreamedChan(ctx, agent, userRequest)
	if err != nil {
		http.Error(w, fmt.Sprintf("Failed to start agent: %v", err), http.StatusInternalServerError)
		return
	}

	// Stream response
	flusher, ok := w.(http.Flusher)
	if !ok {
		http.Error(w, "Streaming not supported", http.StatusInternalServerError)
		return
	}

	// Write initial response
	fmt.Fprintf(w, "Agent Response:\n")
	flusher.Flush()

	// Process events
	for {
		select {
		case <-ctx.Done():
			logger.WarnContext(ctx, "Request context cancelled", "error", ctx.Err())
			fmt.Fprintf(w, "\n[Request cancelled: %v]\n", ctx.Err())
			flusher.Flush()
			// Context is cancelled but tracing might still be trying to export
			return

		case event, ok := <-eventsCh:
			if !ok {
				// Stream finished
				fmt.Fprintf(w, "\n[Stream completed]\n")
				fmt.Fprintf(w, "Usage: %d input tokens, %d output tokens\n",
					usageTracker.InputTokens, usageTracker.OutputTokens)
				flusher.Flush()
				logger.InfoContext(ctx, "Agent stream completed")

				// Important: We return here while traces might still be exporting
				// This should trigger the context cancellation issue
				return
			}

			// Handle different event types
			switch e := event.(type) {
			case agents.RawResponsesStreamEvent:
				switch e.Data.Type {
				case "response.output_text.delta":
					if e.Data.Delta != "" {
						fmt.Fprintf(w, "%s", e.Data.Delta)
						flusher.Flush()
					}
				case "response.created":
					fmt.Fprintf(w, "\n[Agent thinking...]\n")
					flusher.Flush()
				case "response.completed":
					fmt.Fprintf(w, "\n[Agent completed]\n")
					flusher.Flush()
				}
			}

		case err := <-errCh:
			if err != nil {
				logger.ErrorContext(ctx, "Agent error", "error", err)
				fmt.Fprintf(w, "\n[Error: %v]\n", err)
				flusher.Flush()
				return
			}
		}
	}
}

[richard-maxima]

Wanted to revive this thread as I'm currently dealing with this issue as well. It seems like the package is using the ctx that comes from the request as the request of the goroutine that flushes the traces, which results in the goroutine trying to flush the traces to OAI with a cancelled ctx.
@matteo-grella
(from tracing/processors.go)

func (b *BatchTraceProcessor) ensureWorkerStarted(ctx context.Context) {
	// Fast path without holding the lock.
	if b.workerRunning.Load() {
		return
	}

	b.workerMu.Lock()
	defer b.workerMu.Unlock()
	if b.workerRunning.Load() {
		return
	}

	b.workerDoneChan = make(chan struct{})
	b.workerRunning.Store(true)

	go func() {
		defer func() {
			b.workerMu.Lock()
			defer b.workerMu.Unlock()
			b.workerRunning.Store(false)
			close(b.workerDoneChan)
		}()

		err := b.run(ctx) // lifecycle of the bg exporter shouldn't be tied to the request
        // err := b.run(context.Background())
		if err != nil {
			Logger().Error("BatchTraceProcessor worker error", slog.String("error", err.Error()))
		}
	}()
}