Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
90 changes: 12 additions & 78 deletions aibridge/bridge.go
Original file line number Diff line number Diff line change
Expand Up @@ -6,30 +6,27 @@ import (
"fmt"
"net/http"
"net/url"
"strconv"
"strings"
"sync"
"time"

"github.com/google/uuid"
"github.com/hashicorp/go-multierror"
"github.com/sony/gobreaker/v2"
"go.opentelemetry.io/otel/codes"
"go.opentelemetry.io/otel/trace"
"golang.org/x/net/http/httpguts"
"golang.org/x/xerrors"

"cdr.dev/slog/v3"
"github.com/coder/coder/v2/aibridge/circuitbreaker"
aibclient "github.com/coder/coder/v2/aibridge/client"
aibcontext "github.com/coder/coder/v2/aibridge/context"
"github.com/coder/coder/v2/aibridge/intercept"
"github.com/coder/coder/v2/aibridge/interceptionerror"
"github.com/coder/coder/v2/aibridge/mcp"
"github.com/coder/coder/v2/aibridge/metrics"
"github.com/coder/coder/v2/aibridge/provider"
"github.com/coder/coder/v2/aibridge/recorder"
"github.com/coder/coder/v2/aibridge/routing"
"github.com/coder/coder/v2/aibridge/tracing"
agplaibridge "github.com/coder/coder/v2/coderd/aibridge"
"github.com/coder/quartz"
)

Expand Down Expand Up @@ -80,24 +77,10 @@ func NewRequestBridge(ctx context.Context, providers []provider.Provider, rec re
}

// Create per-provider circuit breaker if configured
cfg := prov.CircuitBreakerConfig()
providerName := prov.Name()
onChange := func(endpoint, model string, from, to gobreaker.State) {
logger.Info(context.Background(), "circuit breaker state change",
slog.F("provider", providerName),
slog.F("endpoint", endpoint),
slog.F("model", model),
slog.F("from", from.String()),
slog.F("to", to.String()),
)
if m != nil {
m.CircuitBreakerState.WithLabelValues(providerName, endpoint, model).Set(circuitbreaker.StateToGaugeValue(to))
if to == gobreaker.StateOpen {
m.CircuitBreakerTrips.WithLabelValues(providerName, endpoint, model).Inc()
}
}
}
cbs := circuitbreaker.NewProviderCircuitBreakers(providerName, cfg, onChange, m)
cbs := circuitbreaker.NewProviderCircuitBreakers(
providerName, prov.CircuitBreakerConfig(), logger, m,
)

// Add the known provider-specific routes which are bridged (i.e. intercepted and augmented).
for _, path := range prov.BridgedRoutes() {
Expand Down Expand Up @@ -163,10 +146,10 @@ func newInterceptionProcessor(p provider.Provider, cbs *circuitbreaker.ProviderC

// We execute this before CreateInterceptor since the interceptors
// read the request body and don't reset them.
client := GuessClient(r)
sessionID := GuessSessionID(client, r)
client := aibclient.GuessClient(r)
sessionID := aibclient.GuessSessionID(client, r)

if isWebSocketUpgrade(r) {
if aibclient.IsWebSocketUpgrade(r) {
route := strings.TrimPrefix(r.URL.Path, fmt.Sprintf("/%s", p.Name()))
logger.Debug(ctx, "rejecting unsupported WebSocket upgrade",
slog.F("provider", p.Name()),
Expand All @@ -181,9 +164,9 @@ func newInterceptionProcessor(p provider.Provider, cbs *circuitbreaker.ProviderC
// Read and validate Agent Firewall correlation headers. The
// values are captured here and recorded below; the headers
// themselves are stripped from the upstream request by
// PrepareClientHeaders. Fail closed: reject the request if the
// utils.PrepareClientHeaders. Fail closed: reject the request if the
// headers are partial or malformed.
agentFirewallSessionID, agentFirewallSeqNumber, err := extractAgentFirewallHeaders(r)
agentFirewallSessionID, agentFirewallSeqNumber, err := aibclient.ExtractAgentFirewallHeaders(r)
if err != nil {
logger.Warn(ctx, "rejecting request with invalid agent firewall headers", slog.Error(err))
http.Error(w, "invalid agent firewall headers", http.StatusBadRequest)
Expand Down Expand Up @@ -250,7 +233,7 @@ func newInterceptionProcessor(p provider.Provider, cbs *circuitbreaker.ProviderC
CorrelatingToolCallID: interceptor.CorrelatingToolCallID(),
AgentFirewallSessionID: agentFirewallSessionID,
AgentFirewallSequenceNumber: agentFirewallSeqNumber,
CredentialKind: string(cred.Kind()),
CredentialKind: cred.Kind(),
CredentialHint: cred.Hint(),
}); err != nil {
span.SetStatus(codes.Error, fmt.Sprintf("failed to record interception: %v", err))
Expand Down Expand Up @@ -285,7 +268,7 @@ func newInterceptionProcessor(p provider.Provider, cbs *circuitbreaker.ProviderC
// For a centralized pool, the hint now reflects the last key the
// failover loop attempted.
credCtx := intercept.WithCredentialInfo(ctx, cred)
errType, errMsg := categorizeInterceptionError(p, execErr)
errType, errMsg := interceptionerror.Categorize(p, execErr)
if execErr != nil {
if m != nil {
m.InterceptionCount.WithLabelValues(p.Name(), interceptor.Model(), metrics.InterceptionCountStatusFailed, route, r.Method, actor.ID, string(client)).Add(1)
Expand All @@ -311,13 +294,6 @@ func newInterceptionProcessor(p provider.Provider, cbs *circuitbreaker.ProviderC
}
}

// isWebSocketUpgrade reports whether r is a WebSocket opening handshake.
func isWebSocketUpgrade(r *http.Request) bool {
return r.Method == http.MethodGet &&
httpguts.HeaderValuesContainsToken(r.Header.Values("Connection"), "upgrade") &&
httpguts.HeaderValuesContainsToken(r.Header.Values("Upgrade"), "websocket")
}

// ServeHTTP exposes the internal http.Handler, which has all [Provider]s' routes registered.
// It also tracks inflight requests.
func (b *RequestBridge) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
Expand Down Expand Up @@ -346,45 +322,3 @@ func (b *RequestBridge) Shutdown(ctx context.Context) error {

return err
}

// extractAgentFirewallHeaders reads and parses the Agent Firewall
// correlation headers from the request. Both headers must be present
// together with a valid UUID session ID and a non-negative int32
// sequence number, or both must be absent. Partial or malformed headers
// return an error so the caller can reject the request (fail closed).
func extractAgentFirewallHeaders(r *http.Request) (sessionID *string, seqNumber *int32, err error) {
rawSessionID := r.Header.Get(agplaibridge.HeaderAgentFirewallSessionID)
rawSeqNumber := r.Header.Get(agplaibridge.HeaderAgentFirewallSequenceNumber)

hasSessionID := rawSessionID != ""
hasSeqNumber := rawSeqNumber != ""

switch {
case !hasSessionID && !hasSeqNumber:
// Neither header present; request did not traverse Agent Firewall.
return nil, nil, nil
case hasSessionID && !hasSeqNumber:
return nil, nil, xerrors.Errorf("agent firewall session ID header present without sequence number")
case !hasSessionID && hasSeqNumber:
return nil, nil, xerrors.Errorf("agent firewall sequence number header present without session ID")
}

// Both headers present; validate the session ID is a UUID. Storing an
// invalid value would silently drop the firewall correlation to NULL
// downstream, so reject it here instead.
if _, parseErr := uuid.Parse(rawSessionID); parseErr != nil {
return nil, nil, xerrors.Errorf("invalid agent firewall session ID %q: %w", rawSessionID, parseErr)
}

// Parse the sequence number.
n, err := strconv.ParseInt(rawSeqNumber, 10, 32)
if err != nil {
return nil, nil, xerrors.Errorf("invalid agent firewall sequence number %q: %w", rawSeqNumber, err)
}
if n < 0 {
return nil, nil, xerrors.Errorf("invalid agent firewall sequence number %q: must be non-negative", rawSeqNumber)
}

n32 := int32(n)
return &rawSessionID, &n32, nil
}
151 changes: 0 additions & 151 deletions aibridge/bridge_internal_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,6 @@ import (

"cdr.dev/slog/v3/sloggers/slogtest"
"github.com/coder/coder/v2/aibridge/mcpmock"
agplaibridge "github.com/coder/coder/v2/coderd/aibridge"
"github.com/coder/coder/v2/testutil"
)

Expand All @@ -24,156 +23,6 @@ func (b *RequestBridge) InflightRequests() int {
return b.inflight.active
}

func TestIsWebSocketUpgrade(t *testing.T) {
t.Parallel()

tests := []struct {
name string
method string
connection string
upgrade string
want bool
}{
{name: "websocket upgrade", method: http.MethodGet, connection: "keep-alive, Upgrade", upgrade: "WebSocket", want: true},
{name: "non-GET request", method: http.MethodPost, connection: "Upgrade", upgrade: "websocket", want: false},
{name: "missing connection upgrade", method: http.MethodGet, connection: "keep-alive", upgrade: "websocket", want: false},
{name: "different upgrade protocol", method: http.MethodGet, connection: "Upgrade", upgrade: "h2c", want: false},
}

for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()

req, err := http.NewRequestWithContext(t.Context(), tc.method, "/", nil)
require.NoError(t, err)
req.Header.Set("Connection", tc.connection)
req.Header.Set("Upgrade", tc.upgrade)

assert.Equal(t, tc.want, isWebSocketUpgrade(req))
})
}
}

func TestExtractAgentFirewallHeaders(t *testing.T) {
t.Parallel()

const validSessionID = "e5f6a7b8-1234-5678-9abc-def012345678"

ptr := func(s string) *string { return &s }

cases := []struct {
name string
// sessionID and seqNumber set the corresponding headers when
// non-nil. A nil value leaves the header unset.
sessionID *string
seqNumber *string

wantErr bool
errContains string
wantSession *string
wantSeq *int32
}{
{
name: "both headers present",
sessionID: ptr(validSessionID),
seqNumber: ptr("42"),
wantSession: ptr(validSessionID),
wantSeq: int32Ptr(42),
},
{
name: "no headers present",
},
{
name: "only session ID returns error",
sessionID: ptr(validSessionID),
wantErr: true,
errContains: "without sequence number",
},
{
name: "only sequence number returns error",
seqNumber: ptr("7"),
wantErr: true,
errContains: "without session ID",
},
{
name: "sequence number zero",
sessionID: ptr(validSessionID),
seqNumber: ptr("0"),
wantSession: ptr(validSessionID),
wantSeq: int32Ptr(0),
},
{
name: "invalid session ID returns error",
sessionID: ptr("not-a-uuid"),
seqNumber: ptr("42"),
wantErr: true,
errContains: "invalid agent firewall session ID",
},
{
name: "invalid sequence number returns error",
sessionID: ptr(validSessionID),
seqNumber: ptr("not-a-number"),
wantErr: true,
errContains: "invalid agent firewall sequence number",
},
{
name: "negative sequence number returns error",
sessionID: ptr(validSessionID),
seqNumber: ptr("-1"),
wantErr: true,
errContains: "must be non-negative",
},
{
name: "sequence number exceeding int32 range returns error",
sessionID: ptr(validSessionID),
seqNumber: ptr("2147483648"), // max int32 + 1
wantErr: true,
errContains: "invalid agent firewall sequence number",
},
}

for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()

req, err := http.NewRequestWithContext(t.Context(), http.MethodPost, "/", nil)
require.NoError(t, err)
if tc.sessionID != nil {
req.Header.Set(agplaibridge.HeaderAgentFirewallSessionID, *tc.sessionID)
}
if tc.seqNumber != nil {
req.Header.Set(agplaibridge.HeaderAgentFirewallSequenceNumber, *tc.seqNumber)
}

sessionID, seqNumber, extractErr := extractAgentFirewallHeaders(req)

if tc.wantErr {
require.Error(t, extractErr)
assert.Contains(t, extractErr.Error(), tc.errContains)
assert.Nil(t, sessionID)
assert.Nil(t, seqNumber)
return
}

require.NoError(t, extractErr)
if tc.wantSession == nil {
assert.Nil(t, sessionID)
} else {
require.NotNil(t, sessionID)
assert.Equal(t, *tc.wantSession, *sessionID)
}
if tc.wantSeq == nil {
assert.Nil(t, seqNumber)
} else {
require.NotNil(t, seqNumber)
assert.Equal(t, *tc.wantSeq, *seqNumber)
}
})
}
}

func int32Ptr(n int32) *int32 { return &n }

// TestRequestBridgeShutdownDoesNotWaitForCanceledHandler verifies shutdown
// returns even when a canceled handler remains blocked.
func TestRequestBridgeShutdownDoesNotWaitForCanceledHandler(t *testing.T) {
Expand Down
28 changes: 26 additions & 2 deletions aibridge/circuitbreaker/circuitbreaker.go
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@ package circuitbreaker

import (
"bufio"
"context"
"errors"
"fmt"
"net"
Expand All @@ -11,6 +12,7 @@ import (
"github.com/sony/gobreaker/v2"
"golang.org/x/xerrors"

"cdr.dev/slog/v3"
"github.com/coder/coder/v2/aibridge/config"
"github.com/coder/coder/v2/aibridge/metrics"
)
Expand Down Expand Up @@ -43,11 +45,33 @@ type ProviderCircuitBreakers struct {
metrics *metrics.Metrics
}

// NewProviderCircuitBreakers creates circuit breakers for a single provider.
// NewProviderCircuitBreakers creates provider circuit breakers with
// state-change logging and metrics. Returns nil if cfg is nil.
func NewProviderCircuitBreakers(provider string, cfg *config.CircuitBreaker, logger slog.Logger, m *metrics.Metrics) *ProviderCircuitBreakers {
onChange := func(endpoint, model string, from, to gobreaker.State) {
logger.Info(context.Background(), "circuit breaker state change",
slog.F("provider", provider),
slog.F("endpoint", endpoint),
slog.F("model", model),
slog.F("from", from.String()),
slog.F("to", to.String()),
)
if m != nil {
m.CircuitBreakerState.WithLabelValues(provider, endpoint, model).Set(StateToGaugeValue(to))
if to == gobreaker.StateOpen {
m.CircuitBreakerTrips.WithLabelValues(provider, endpoint, model).Inc()
}
}
}
return NewProviderCircuitBreakersWithCallback(provider, cfg, onChange, m)
}

// NewProviderCircuitBreakersWithCallback creates circuit breakers for a single
// provider with a caller-supplied state-change callback.
// Returns nil if cfg is nil (no circuit breaker protection).
// onChange is called when circuit state changes.
// metrics is used to record circuit breaker reject counts (can be nil).
func NewProviderCircuitBreakers(provider string, cfg *config.CircuitBreaker, onChange func(endpoint, model string, from, to gobreaker.State), m *metrics.Metrics) *ProviderCircuitBreakers {
func NewProviderCircuitBreakersWithCallback(provider string, cfg *config.CircuitBreaker, onChange func(endpoint, model string, from, to gobreaker.State), m *metrics.Metrics) *ProviderCircuitBreakers {
if cfg == nil {
return nil
}
Expand Down
Loading
Loading