Method proxyOptimistic

cmd/run/socket/proxy.go:207–315

proxyOptimistic peeks at buffered bytes available on the client side to guess the protocol. If a known protocol is found, it passes control to that protocol's handler. Otherwise, it falls back to the raw handler.

(cli, srv *bufConn)

// guess the protocol. If a known protocol is found, it passes control to that
// protocol's handler. Otherwise, it falls back to the raw handler.
func (p *proxy) proxyOptimistic(cli, srv *bufConn) error {
	slog.Debug("starting proxyOptimistic", "proxy", p)

	errs := make(chan error, 2)

	// While we need to sample client's TCP bytes to see if it's HTTP and/or TLS
	// or something else, we can't synchronously wait for the client's first
	// bytes. Doing so would break protocols that expect the server side to
	// talk first. HTTP and TLS don't behave this way, but since those are not
	// the only protocols we'll be proxying (we intercept all TCP connections at
	// the socket level), the sampling strategy needs to be robust.
	var race atomic.Bool

	go func() {
		if _, err := srv.peekSample(); err != nil {
			if race.Load() {
				errs <- fmt.Errorf("server: peek sample: %w", err)
			} else {
				errs <- nil
			}
			return
		}

		if isHTTP2Enabled {
			// Give the client up to few hundred milliseconds to catch up so it has a
			// better chance of winning the race in situations where the first server
			// bytes arrive fractions of a millisecond before the first client bytes
			// (e.g. when a HTTP/2 server pushes a SETTINGS frame before the client
			// sends its first frame). Doing this greatly increases wire protocol
			// guess accuracy. While this admittedly adds upto 1ms latency in obscure
			// protocols where the server is required to talk first, the trade-off is
			// well worth it because Subtrace is not designed for those protocols.
			start := time.Now()
			for i := 0; ; i++ {
				if race.Load() {
					break
				}
				if i&15 == 15 {
					time.Sleep(20 * time.Microsecond)
				}
				if race.Load() {
					break
				}
				if time.Since(start) >= 1000*time.Microsecond {
					break
				}
				if race.Load() {
					break
				}
				runtime.Gosched()
				if race.Load() {
					break
				}
			}
		}

		if winner := race.CompareAndSwap(false, true); !winner {
			errs <- nil