diff --git a/cmd/teeproxy/main.go b/cmd/teeproxy/main.go
deleted file mode 100644
index 7f38cab..0000000
--- a/cmd/teeproxy/main.go
+++ /dev/null
@@ -1,108 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The teeproxy hits the frontend with a URL from godoc.org.
-package main
-
-import (
-	"context"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"os"
-
-	"golang.org/x/pkgsite/internal/auth"
-	"golang.org/x/pkgsite/internal/breaker"
-	"golang.org/x/pkgsite/internal/config"
-	"golang.org/x/pkgsite/internal/dcensus"
-	"golang.org/x/pkgsite/internal/log"
-	"golang.org/x/pkgsite/internal/secrets"
-	"golang.org/x/pkgsite/internal/teeproxy"
-)
-
-func main() {
-	var credsFile = flag.String("creds", "", "filename for credentials, when running locally")
-	flag.Usage = func() {
-		fmt.Fprintf(flag.CommandLine.Output(), "usage: %s [flags]\n", os.Args[0])
-		flag.PrintDefaults()
-	}
-	flag.Parse()
-	ctx := context.Background()
-
-	cfg, err := config.Init(ctx)
-	if err != nil {
-		log.Fatal(ctx, err)
-	}
-	cfg.Dump(os.Stderr)
-
-	log.SetLevel(cfg.LogLevel)
-	if cfg.OnGCP() {
-		_, err := log.UseStackdriver(ctx, cfg, "teeproxy-log")
-		if err != nil {
-			log.Fatal(ctx, err)
-		}
-	}
-	client := &http.Client{}
-	var jsonCreds []byte
-	if *credsFile != "" {
-		jsonCreds, err = ioutil.ReadFile(*credsFile)
-		if err != nil {
-			log.Fatal(ctx, err)
-		}
-	} else {
-		const secretName = "load-test-agent-creds"
-		log.Infof(ctx, "getting secret %q", secretName)
-		s, err := secrets.Get(context.Background(), secretName)
-		if err != nil {
-			log.Infof(ctx, "secret %q not found", secretName)
-		} else {
-			jsonCreds = []byte(s)
-		}
-	}
-
-	if jsonCreds != nil {
-		client, err = auth.NewClient(ctx, jsonCreds, false)
-		if err != nil {
-			log.Fatal(ctx, err)
-		}
-	}
-
-	views := append(dcensus.ServerViews,
-		teeproxy.TeeproxyGddoRequestCount,
-		teeproxy.TeeproxyPkgGoDevRequestCount,
-		teeproxy.TeeproxyGddoRequestLatencyDistribution,
-		teeproxy.TeeproxyPkgGoDevRequestLatencyDistribution,
-		teeproxy.TeeproxyPkgGoDevBrokenPathCount,
-	)
-	dcensus.Init(cfg, views...)
-
-	http.HandleFunc("/favicon.ico", func(w http.ResponseWriter, r *http.Request) {
-		http.ServeFile(w, r, "content/static/img/favicon.ico")
-	})
-	server, err := teeproxy.NewServer(teeproxy.Config{
-		AuthKey:   cfg.Teeproxy.AuthKey,
-		AuthValue: cfg.Teeproxy.AuthValue,
-		Rate:      cfg.Teeproxy.Rate,
-		Burst:     cfg.Teeproxy.Burst,
-		BreakerConfig: breaker.Config{
-			FailsToRed:       cfg.Teeproxy.FailsToRed,
-			FailureThreshold: cfg.Teeproxy.FailureThreshold,
-			GreenInterval:    cfg.Teeproxy.GreenInterval,
-			MinTimeout:       cfg.Teeproxy.MinTimeout,
-			MaxTimeout:       cfg.Teeproxy.MaxTimeout,
-			SuccsToGreen:     cfg.Teeproxy.SuccsToGreen,
-		},
-		Hosts:  cfg.Teeproxy.Hosts,
-		Client: client,
-	})
-	if err != nil {
-		log.Fatal(ctx, err)
-	}
-	http.Handle("/", server)
-
-	addr := cfg.HostAddr("localhost:8020")
-	log.Infof(ctx, "Listening on addr %s", addr)
-	log.Fatal(ctx, http.ListenAndServe(addr, nil))
-}
diff --git a/internal/breaker/breaker.go b/internal/breaker/breaker.go
deleted file mode 100644
index 98e40a7..0000000
--- a/internal/breaker/breaker.go
+++ /dev/null
@@ -1,271 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package breaker implements the circuit breaker pattern.
-// see https://docs.microsoft.com/en-us/previous-versions/msp-n-p/dn589784(v=pandp.10).
-//
-// This package uses different terminologies for the state of the circuit breaker
-// for better readability. Since it is unintuitive for users unfamiliar with
-// circuits that a "closed" state means to "let the requests pass through" and
-// "open" state means "don't let anything through", we use the colors red,
-// yellow, and green instead of open, half-open, and closed, respectively.
-//
-// When the API is stable, this package may be factored out to an external location.
-package breaker
-
-import (
-	"fmt"
-	"sync"
-	"time"
-)
-
-// For testing.
-var timeNow = time.Now
-
-// numBuckets is the number of buckets in the breaker's sliding window.
-const numBuckets = 8
-
-// State represents the current state the breaker is in.
-type State int
-
-// The breaker can have three states: Red, Yellow, or Green.
-const (
-	// Red state means that requests should not be allowed.
-	Red State = iota
-	// Yellow state means that certain requests may proceed with caution.
-	Yellow
-	// Green state means that requests are allowed to pass.
-	Green
-)
-
-// String returns the string version of the state.
-func (s State) String() string {
-	switch s {
-	case Red:
-		return "red state"
-	case Yellow:
-		return "yellow state"
-	case Green:
-		return "green state"
-	default:
-		return "invalid state"
-	}
-}
-
-// Config holds the configuration values for a breaker.
-type Config struct {
-	// FailsToRed is the number of failures to exceed before the breaker shifts
-	// from green to red state.
-	FailsToRed int
-	// FailureThreshold is the failure ratio to exceed before the breaker
-	// shifts from green to red state.
-	FailureThreshold float64
-	// GreenInterval is the length of the interval with which the breaker
-	// checks for conditions to move from green to red state.
-	GreenInterval time.Duration
-	// MinTimeout is the minimum timeout period that the breaker stays in the
-	// red state before moving to the yellow state.
-	MinTimeout time.Duration
-	// MaxTimeout is the maxmimum timeout period that the breaker stays in the
-	// red state before moving to the yellow state.
-	MaxTimeout time.Duration
-	// SuccsToGreen is the number of successes required to shift from the
-	// yellow state to the green state.
-	SuccsToGreen int
-}
-
-// Breaker represents a circuit breaker.
-//
-// In the green state, the breaker remains green until it encounters a time
-// window of length GreenInterval where there are more than FailsToRed failures
-// and a failureRatio of more than FailureThreshold, in which case the
-// state becomes red.
-//
-// In the red state, the breaker halts all requests and waits for a timeout period
-// before shifting to the yellow state.
-//
-// In the yellow state, the breaker allows the first SuccsToGreen requests. If
-// any of these fail, the state reverts to red. Otherwise, the state becomes
-// green again.
-//
-// The timeout period is initially set to MinTimeout when the breaker shifts
-// from green to yellow. By default, the timeout period is doubled each time
-// the breaker fails to shift from the yellow state to the green state and is
-// capped at MaxTimeout.
-type Breaker struct {
-	config Config
-
-	// buckets represents a time sliding window, implemented as a ring buffer.
-	buckets [numBuckets]bucket
-	// granularity is the length of time each bucket is responsible for.
-	granularity time.Duration
-
-	mu               sync.Mutex
-	state            State
-	cur              int
-	consecutiveSuccs int
-	timeout          time.Duration
-	lastEvent        time.Time
-}
-
-// New creates a Breaker with the given configuration.
-func New(config Config) (*Breaker, error) {
-	switch {
-	case config.FailsToRed <= 0:
-		return nil, fmt.Errorf("illegal value for FailsToRed")
-	case config.FailureThreshold <= 0, config.FailureThreshold > 1:
-		return nil, fmt.Errorf("illegal value for FailureThreshold")
-	case config.GreenInterval <= 0:
-		return nil, fmt.Errorf("illegal value for GreenInterval")
-	case config.MinTimeout <= 0:
-		return nil, fmt.Errorf("illegal value for MinTimeout")
-	case config.MaxTimeout <= 0:
-		return nil, fmt.Errorf("illegal value for MaxTimeout")
-	case config.SuccsToGreen <= 0:
-		return nil, fmt.Errorf("illegal value for SuccsToGreen")
-	default:
-		return &Breaker{
-			config:      config,
-			state:       Green,
-			granularity: config.GreenInterval / numBuckets,
-			timeout:     config.MinTimeout,
-			lastEvent:   timeNow(),
-		}, nil
-	}
-}
-
-// State returns the state of the breaker.
-func (b *Breaker) State() State {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	return b.checkState()
-}
-
-// checkState returns the state of the breaker without obtaining a mutex lock.
-// The state is updated if sufficient time has passed since the last event.
-func (b *Breaker) checkState() State {
-	now := timeNow()
-	if b.state == Red && now.After(b.lastEvent.Add(b.timeout)) {
-		b.state = Yellow
-	}
-	return b.state
-}
-
-// Allow reports whether an event may happen at time now. If Allow returns
-// true, the user must then call Record to register whether the event succeeded.
-func (b *Breaker) Allow() bool {
-	return b.State() != Red
-}
-
-// Record registers the success or failure of an event with the circuit breaker.
-// Use this function after a call to Allow returned true.
-func (b *Breaker) Record(success bool) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-	b.update(timeNow())
-	if success {
-		b.succeeded()
-	} else {
-		b.failed()
-	}
-}
-
-// succeeded signals that an allowed request has succeeded. The breaker state is
-// changed if necessary.
-func (b *Breaker) succeeded() {
-	b.buckets[b.cur].successes++
-	b.consecutiveSuccs++
-	if b.checkState() == Yellow && b.consecutiveSuccs >= b.config.SuccsToGreen {
-		b.state = Green
-		b.timeout = b.config.MinTimeout
-		b.resetCounts()
-	}
-}
-
-// failed signals that an allowed request has failed. The breaker state is
-// changed if necessary.
-func (b *Breaker) failed() {
-	b.buckets[b.cur].failures++
-	b.consecutiveSuccs = 0
-	switch b.checkState() {
-	case Yellow:
-		b.increaseTimeout()
-		b.state = Red
-	case Green:
-		// Check conditions to move to red state.
-		successes, failures := b.counts()
-		totalRequests := successes + failures
-		if failures <= b.config.FailsToRed || totalRequests == 0 {
-			return
-		}
-		failureRatio := float64(failures) / float64(totalRequests)
-		if failureRatio > b.config.FailureThreshold {
-			b.state = Red
-		}
-	}
-}
-
-// update updates the values of breaker due to the passage of time.
-func (b *Breaker) update(now time.Time) {
-	// Ignore updates from the past.
-	if now.Before(b.lastEvent) {
-		return
-	}
-	since := now.Sub(b.lastEvent)
-	b.advance(int(since / b.granularity))
-	b.lastEvent = now
-}
-
-// advance advances the breaker's sliding window by n buckets. The counts of
-// successes and failures are also updated to include only the buckets in the
-// current window.
-func (b *Breaker) advance(n int) {
-	if n >= len(b.buckets) {
-		b.resetCounts()
-		b.cur = 0
-		return
-	}
-	for i := 0; i < n; i++ {
-		b.cur = (b.cur + 1) % len(b.buckets)
-		b.buckets[b.cur].reset()
-	}
-}
-
-// counts returns the total number of successes and failures in the breaker's
-// sliding window.
-func (b *Breaker) counts() (successes, failures int) {
-	for _, bu := range b.buckets {
-		successes += bu.successes
-		failures += bu.failures
-	}
-	return successes, failures
-}
-
-// resetCounts resets all the buckets in breaker.
-func (b *Breaker) resetCounts() {
-	for i := range b.buckets {
-		b.buckets[i].reset()
-	}
-}
-
-// increaseTimeout exponentially increases the breaker's timeout period,
-// capped at maxTimeout.
-func (b *Breaker) increaseTimeout() {
-	if 2*b.timeout <= b.config.MaxTimeout {
-		b.timeout *= 2
-		return
-	}
-	b.timeout = b.config.MaxTimeout
-}
-
-type bucket struct {
-	successes int
-	failures  int
-}
-
-// reset resets the values in the bucket.
-func (bu *bucket) reset() {
-	bu.successes = 0
-	bu.failures = 0
-}
diff --git a/internal/breaker/breaker_test.go b/internal/breaker/breaker_test.go
deleted file mode 100644
index b773980..0000000
--- a/internal/breaker/breaker_test.go
+++ /dev/null
@@ -1,717 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package breaker
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-)
-
-func TestBucketReset(t *testing.T) {
-	bu := bucket{12, 8}
-	bu.reset()
-	if bu.successes != 0 {
-		t.Errorf("got successes = %d, want %d", bu.successes, 0)
-	}
-	if bu.failures != 0 {
-		t.Errorf("got failures = %d, want %d", bu.failures, 0)
-	}
-}
-
-func TestResetCounts(t *testing.T) {
-	b := newTestBreaker(Config{})
-	for i := 0; i < len(b.buckets); i++ {
-		b.buckets[i].successes = 10
-		b.buckets[i].failures = 15
-	}
-
-	b.resetCounts()
-	testBuckets(t, b.buckets[:], 0, 0)
-	testCounts(t, b, 0, 0, 0)
-}
-
-func TestNewBreaker(t *testing.T) {
-	timeNow = func() time.Time {
-		return time.Date(2020, time.May, 26, 18, 0, 0, 0, time.UTC)
-	}
-	got, err := New(Config{
-		FailsToRed:       10,
-		FailureThreshold: 0.65,
-		GreenInterval:    20 * time.Second,
-		MinTimeout:       30 * time.Second,
-		MaxTimeout:       16 * time.Minute,
-		SuccsToGreen:     15,
-	})
-	if err != nil {
-		t.Fatalf("New() returned %e, want nil", err)
-	}
-	want := &Breaker{
-		config: Config{
-			FailsToRed:       10,
-			FailureThreshold: 0.65,
-			GreenInterval:    20 * time.Second,
-			MinTimeout:       30 * time.Second,
-			MaxTimeout:       16 * time.Minute,
-			SuccsToGreen:     15,
-		},
-		buckets:          [numBuckets]bucket{},
-		granularity:      2500 * time.Millisecond,
-		state:            Green,
-		cur:              0,
-		consecutiveSuccs: 0,
-		timeout:          30 * time.Second,
-		lastEvent:        time.Date(2020, time.May, 26, 18, 0, 0, 0, time.UTC),
-	}
-
-	diff := cmp.Diff(want, got, cmpopts.IgnoreUnexported(sync.Mutex{}), cmp.AllowUnexported(Breaker{}, bucket{}))
-	if diff != "" {
-		t.Fatalf("mismatch (-want +got):\n%s", diff)
-	}
-}
-
-func TestIllegalBreaker(t *testing.T) {
-	for _, test := range []struct {
-		name   string
-		config Config
-	}{
-		{
-			name: "FailsToRed cannot be 0",
-			config: Config{
-				FailsToRed:       0,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "FailsToRed cannot be negative",
-			config: Config{
-				FailsToRed:       -5,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "FailureThreshold cannot be 0",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "FailureThreshold cannot be negative",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: -0.8,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "FailureThreshold cannot exceed 1",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 1.2,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "GreenInterval cannot be 0",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    0,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "GreenInterval cannot be negative",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    -4 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "MinTimeout cannot be 0",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       0,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "MinTimeout cannot be negative",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       -2 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "MaxTimeout cannot be 0",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       0,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "MaxTimeout cannot be negative",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       -12 * time.Minute,
-				SuccsToGreen:     15,
-			},
-		},
-		{
-			name: "SuccsToGreen cannot be 0",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     0,
-			},
-		},
-		{
-			name: "SuccsToGreen cannot be negative",
-			config: Config{
-				FailsToRed:       8,
-				FailureThreshold: 0.65,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     -7,
-			},
-		},
-		{
-			name: "multiple illegal values return error",
-			config: Config{
-				FailsToRed:       0,
-				FailureThreshold: 1.4,
-				GreenInterval:    20 * time.Second,
-				MinTimeout:       -30 * time.Second,
-				MaxTimeout:       16 * time.Minute,
-				SuccsToGreen:     100,
-			},
-		},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			b, err := New(test.config)
-			if err == nil {
-				t.Fatalf("New() returned nil error")
-			}
-			if b != nil {
-				t.Fatalf("New() returned %+v, want nil", b)
-			}
-		})
-	}
-}
-
-func TestBreakerGranularity(t *testing.T) {
-	for _, test := range []struct {
-		config Config
-		want   time.Duration
-	}{
-		{
-			config: Config{},
-			want:   1250 * time.Millisecond,
-		},
-		{
-			config: Config{GreenInterval: 1 * time.Second},
-			want:   125 * time.Millisecond,
-		},
-		{
-			config: Config{GreenInterval: 3 * time.Second},
-			want:   375 * time.Millisecond,
-		},
-		{
-			config: Config{GreenInterval: 1 * time.Minute},
-			want:   7500 * time.Millisecond,
-		},
-		{
-			config: Config{GreenInterval: 1 * time.Hour},
-			want:   450 * time.Second,
-		},
-	} {
-		b := newTestBreaker(test.config)
-		if b.granularity != test.want {
-			t.Errorf("b.granularity = %d, want %d", b.granularity, test.want)
-		}
-	}
-}
-
-func TestState(t *testing.T) {
-	for _, want := range []State{
-		Green,
-		Yellow,
-		Red,
-	} {
-		b := newTestBreaker(Config{})
-		b.state = want
-		if got := b.checkState(); got != want {
-			t.Errorf("b.checkState() = %s, got %s", got, want)
-		}
-		if got := b.State(); got != want {
-			t.Errorf("b.State() = %s, want %s", got, want)
-		}
-	}
-}
-func TestAllow(t *testing.T) {
-	for _, test := range []struct {
-		state       State
-		shouldAllow bool
-	}{
-		{
-			state:       Green,
-			shouldAllow: true,
-		},
-		{
-			state:       Yellow,
-			shouldAllow: true,
-		},
-		{
-			state:       Red,
-			shouldAllow: false,
-		},
-	} {
-		b := newTestBreaker(Config{})
-		b.state = test.state
-		allowed := b.Allow()
-		if allowed != test.shouldAllow {
-			t.Errorf("b.Allow() = %t in %s, want %t", allowed, test.state, test.shouldAllow)
-		}
-	}
-}
-
-func TestSuccesses(t *testing.T) {
-	b := newTestBreaker(Config{})
-	b.succeeded()
-	testCounts(t, b, 1, 1, 0)
-	b.succeeded()
-	testCounts(t, b, 2, 2, 0)
-	b.succeeded()
-	testCounts(t, b, 3, 3, 0)
-}
-
-func TestFailures(t *testing.T) {
-	b := newTestBreaker(Config{})
-	b.failed()
-	testCounts(t, b, 0, 0, 1)
-	b.failed()
-	testCounts(t, b, 0, 0, 2)
-	b.failed()
-	testCounts(t, b, 0, 0, 3)
-}
-
-func TestSucceededAndFailed(t *testing.T) {
-	b := newTestBreaker(Config{})
-	b.succeeded()
-	testCounts(t, b, 1, 1, 0)
-	b.failed()
-	testCounts(t, b, 0, 1, 1)
-	b.failed()
-	testCounts(t, b, 0, 1, 2)
-	b.succeeded()
-	testCounts(t, b, 1, 2, 2)
-	b.succeeded()
-	testCounts(t, b, 2, 3, 2)
-	b.succeeded()
-	testCounts(t, b, 3, 4, 2)
-	b.failed()
-	testCounts(t, b, 0, 4, 3)
-}
-
-func TestUpdate(t *testing.T) {
-	now := time.Now()
-	b := newTestBreaker(Config{})
-	b.lastEvent = now
-	b.granularity = 1 * time.Second
-	for i := 0; i < len(b.buckets); i++ {
-		b.buckets[i].successes = 4
-		b.buckets[i].failures = 9
-	}
-
-	// Update 0 buckets.
-	b.update(now.Add(-1 * time.Second))
-	if b.cur != 0 {
-		t.Errorf("cur: got %d, want %d", b.cur, 0)
-	}
-	testBuckets(t, b.buckets[:], 4, 9)
-	testCounts(t, b, 0, 4*len(b.buckets), 9*len(b.buckets))
-
-	// Update next 3 buckets.
-	b.update(now.Add(3 * time.Second))
-	if b.cur != 3 {
-		t.Errorf("cur: got %d, want %d", b.cur, 3)
-	}
-	testBuckets(t, b.buckets[:1], 4, 9)
-	testBuckets(t, b.buckets[1:4], 0, 0)
-	testBuckets(t, b.buckets[4:], 4, 9)
-	testCounts(t, b, 0, 4*len(b.buckets)-12, 9*len(b.buckets)-27)
-
-	// Update all buckets.
-	b.update(now.Add(1003 * time.Second))
-	expectedCur := 0
-	if b.cur != expectedCur {
-		t.Errorf("cur: got %d, want %d", b.cur, expectedCur)
-	}
-	testBuckets(t, b.buckets[:], 0, 0)
-	testCounts(t, b, 0, 0, 0)
-}
-
-func TestStateChanges(t *testing.T) {
-	for _, test := range []struct {
-		name         string
-		config       Config
-		preSuccesses int
-		preFailures  int
-		fromState    State
-		allow        bool
-		success      bool
-		sleep        time.Duration
-		toState      State
-	}{
-		{
-			name:         "breaker state remains green when FailsToRed is not exceeded",
-			config:       Config{FailsToRed: 8, FailureThreshold: 0.5},
-			preSuccesses: 6,
-			preFailures:  7,
-			fromState:    Green,
-			allow:        true,
-			success:      false,
-			toState:      Green,
-		},
-		{
-			name:         "breaker state remains green when FailureThreshold is not exceeded",
-			config:       Config{FailsToRed: 2, FailureThreshold: 0.8},
-			preSuccesses: 3,
-			preFailures:  6,
-			fromState:    Green,
-			allow:        true,
-			success:      false,
-			toState:      Green,
-		},
-		{
-			name:         "breaker state remains green when failure ratio = FailureThreshold",
-			config:       Config{FailsToRed: 10, FailureThreshold: 0.5},
-			preSuccesses: 20,
-			preFailures:  19,
-			fromState:    Green,
-			allow:        true,
-			success:      false,
-			toState:      Green,
-		},
-		{
-			name:         "breaker state remains green when failures = FailsToRed",
-			config:       Config{FailsToRed: 10, FailureThreshold: 0.3},
-			preSuccesses: 10,
-			preFailures:  9,
-			fromState:    Green,
-			allow:        true,
-			success:      false,
-			toState:      Green,
-		},
-		{
-			name:         "breaker state changes to red when FailureThreshold is exceeded and after FailsToRed has been exceeded",
-			config:       Config{FailsToRed: 10, FailureThreshold: 0.5},
-			preSuccesses: 20,
-			preFailures:  20,
-			fromState:    Green,
-			allow:        true,
-			success:      false,
-			toState:      Red,
-		},
-		{
-			name:         "breaker state changes to red when FailsToRed is exceeded and after FailureThreshold has been exceeded",
-			config:       Config{FailsToRed: 20, FailureThreshold: 0.3},
-			preSuccesses: 20,
-			preFailures:  20,
-			fromState:    Green,
-			allow:        true,
-			success:      false,
-			toState:      Red,
-		},
-		{
-			name:         "breaker state changes from green to red",
-			config:       Config{FailsToRed: 4, FailureThreshold: 0.5},
-			preSuccesses: 4,
-			preFailures:  4,
-			fromState:    Green,
-			allow:        true,
-			success:      false,
-			toState:      Red,
-		},
-		{
-			name:         "failure in yellow state changes breaker to red state",
-			config:       Config{},
-			preSuccesses: 0,
-			preFailures:  0,
-			fromState:    Yellow,
-			allow:        true,
-			success:      false,
-			toState:      Red,
-		},
-		{
-			name:         "breaker state changes from yellow to green",
-			config:       Config{SuccsToGreen: 1},
-			preSuccesses: 0,
-			preFailures:  0,
-			fromState:    Yellow,
-			allow:        true,
-			success:      true,
-			toState:      Green,
-		},
-		{
-			name:         "breaker state changes from red to yellow",
-			config:       Config{MinTimeout: 1 * time.Second},
-			preSuccesses: 0,
-			preFailures:  0,
-			fromState:    Red,
-			sleep:        1*time.Second + 1*time.Nanosecond,
-			toState:      Yellow,
-		},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			now := time.Time{}
-			timeNow = func() time.Time { return now }
-			b := newTestBreaker(test.config)
-			b.state = test.fromState
-			b.buckets[0].successes = test.preSuccesses
-			b.buckets[0].failures = test.preFailures
-
-			allowed := b.Allow()
-			if allowed != test.allow {
-				t.Fatalf("b.Allow() = %t in %s, want %t", allowed, test.fromState, test.allow)
-			}
-			if test.allow {
-				b.Record(test.success)
-			}
-
-			// Pseudo sleep.
-			now = now.Add(test.sleep)
-
-			if state := b.State(); state != test.toState {
-				t.Errorf("b.State() = %s, want %s", state, test.toState)
-			}
-		})
-	}
-}
-
-func TestRunningBreaker(t *testing.T) {
-	now := time.Time{}
-	timeNow = func() time.Time { return now }
-	b := newTestBreaker(Config{
-		GreenInterval: 5 * time.Second,
-	})
-
-	// The following tests happen sequentially. The tests' states depend on previous tests.
-	for _, test := range []struct {
-		name                 string
-		firstSleep           time.Duration
-		allow                bool
-		secondSleep          time.Duration
-		success              bool
-		wantConsecutiveSuccs int
-		wantSuccesses        int
-		wantFailures         int
-	}{
-		{
-			name:                 "successFunc called after a long time updates counts",
-			firstSleep:           20 * time.Second,
-			allow:                true,
-			secondSleep:          20 * time.Second,
-			success:              true,
-			wantConsecutiveSuccs: 1,
-			wantSuccesses:        1,
-			wantFailures:         0,
-		},
-		{
-			name:                 "success within GreenInterval updates counts correctly",
-			firstSleep:           1 * time.Second,
-			allow:                true,
-			secondSleep:          3 * time.Second,
-			success:              true,
-			wantConsecutiveSuccs: 2,
-			wantSuccesses:        2,
-			wantFailures:         0,
-		},
-		{
-			name:                 "success after a long time updates counts correctly",
-			firstSleep:           30 * time.Second,
-			allow:                true,
-			secondSleep:          80 * time.Second,
-			success:              true,
-			wantConsecutiveSuccs: 3,
-			wantSuccesses:        1,
-			wantFailures:         0,
-		},
-		{
-			name:                 "failure within GreenInterval updates counts correctly",
-			firstSleep:           1 * time.Second,
-			allow:                true,
-			secondSleep:          3 * time.Second,
-			success:              false,
-			wantConsecutiveSuccs: 0,
-			wantSuccesses:        1,
-			wantFailures:         1,
-		},
-		{
-			name:                 "second failure within GreenInterval updates counts correctly",
-			firstSleep:           1 * time.Millisecond,
-			allow:                true,
-			secondSleep:          3 * time.Millisecond,
-			success:              false,
-			wantConsecutiveSuccs: 0,
-			wantSuccesses:        1,
-			wantFailures:         2,
-		},
-		{
-			name:                 "failure after a long time updates counts correctly",
-			firstSleep:           10 * time.Second,
-			allow:                true,
-			secondSleep:          4 * time.Minute,
-			success:              false,
-			wantConsecutiveSuccs: 0,
-			wantSuccesses:        0,
-			wantFailures:         1,
-		},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			now = now.Add(test.firstSleep)
-			allowed := b.Allow()
-
-			if allowed != test.allow {
-				t.Fatalf("breaker.Allow() = %t, want %t", allowed, test.allow)
-			}
-
-			now = now.Add(test.secondSleep)
-			if test.allow {
-				b.Record(test.success)
-			}
-
-			testCounts(t, b, test.wantConsecutiveSuccs, test.wantSuccesses, test.wantFailures)
-		})
-	}
-}
-
-func TestIncreaseTimeout(t *testing.T) {
-	b := newTestBreaker(Config{
-		MinTimeout: 1 * time.Second,
-		MaxTimeout: 12 * time.Second,
-	})
-	b.timeout = 3 * time.Second
-
-	b.increaseTimeout()
-	testTimeouts(t, b, 6*time.Second, 1*time.Second, 12*time.Second)
-	b.increaseTimeout()
-	testTimeouts(t, b, 12*time.Second, 1*time.Second, 12*time.Second)
-	b.increaseTimeout()
-	testTimeouts(t, b, 12*time.Second, 1*time.Second, 12*time.Second)
-
-	b.config.MaxTimeout = 14 * time.Second
-	testTimeouts(t, b, 12*time.Second, 1*time.Second, 14*time.Second)
-	b.increaseTimeout()
-	testTimeouts(t, b, 14*time.Second, 1*time.Second, 14*time.Second)
-	b.increaseTimeout()
-	testTimeouts(t, b, 14*time.Second, 1*time.Second, 14*time.Second)
-}
-
-// newTestBreaker is like New, but with default values for easier testing.
-func newTestBreaker(config Config) *Breaker {
-	if config.FailsToRed <= 0 {
-		config.FailsToRed = 10
-	}
-	if config.FailureThreshold <= 0 {
-		config.FailureThreshold = 0.5
-	}
-	if config.GreenInterval <= 0 {
-		config.GreenInterval = 10 * time.Second
-	}
-	if config.MinTimeout <= 0 {
-		config.MinTimeout = 30 * time.Second
-	}
-	if config.MaxTimeout <= 0 {
-		config.MaxTimeout = 4 * time.Minute
-	}
-	if config.SuccsToGreen <= 0 {
-		config.SuccsToGreen = 20
-	}
-	b, _ := New(config)
-	return b
-}
-
-func testCounts(t *testing.T, b *Breaker, consecutiveSuccs, wantSuccesses, wantFailures int) {
-	if b.consecutiveSuccs != consecutiveSuccs {
-		t.Errorf("b.consecutiveSuccs = %d, want %d", b.consecutiveSuccs, consecutiveSuccs)
-	}
-	successes, failures := b.counts()
-	if successes != wantSuccesses {
-		t.Errorf("successes = %d, want %d", successes, wantSuccesses)
-	}
-	if failures != wantFailures {
-		t.Errorf("failures = %d, want %d", failures, wantFailures)
-	}
-}
-
-func testBuckets(t *testing.T, buckets []bucket, successes, failures int) {
-	for i, bu := range buckets {
-		if bu.successes != successes {
-			t.Errorf("slice bucket %d successes: got %d, want %d", i, bu.successes, successes)
-		}
-		if bu.failures != failures {
-			t.Errorf("slice bucket %d failures: got %d, want %d", i, bu.failures, failures)
-		}
-	}
-}
-
-func testTimeouts(t *testing.T, b *Breaker, timeout, minTimeout, maxTimeout time.Duration) {
-	if b.timeout != timeout {
-		t.Errorf("b.timeout = %s, want %s", b.timeout, timeout)
-	}
-	if b.config.MinTimeout != minTimeout {
-		t.Errorf("b.config.MinTimeout = %s, want %s", b.config.MinTimeout, minTimeout)
-	}
-	if b.config.MaxTimeout != maxTimeout {
-		t.Errorf("b.config.MaxTimeout = %s, want %s", b.config.MaxTimeout, maxTimeout)
-	}
-}
diff --git a/internal/teeproxy/teeproxy.go b/internal/teeproxy/teeproxy.go
deleted file mode 100644
index 29616d8..0000000
--- a/internal/teeproxy/teeproxy.go
+++ /dev/null
@@ -1,457 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package teeproxy provides functionality for running a service which tees
-// traffic to pkg.go.dev.
-package teeproxy
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-
-	"go.opencensus.io/plugin/ochttp"
-	"go.opencensus.io/stats"
-	"go.opencensus.io/stats/view"
-	"go.opencensus.io/tag"
-	"golang.org/x/net/context/ctxhttp"
-	"golang.org/x/pkgsite/internal/breaker"
-	"golang.org/x/pkgsite/internal/derrors"
-	"golang.org/x/pkgsite/internal/log"
-	"golang.org/x/time/rate"
-)
-
-// Server receives requests from godoc.org and tees them to specified hosts.
-type Server struct {
-	hosts    []string
-	client   *http.Client
-	limiter  *rate.Limiter
-	breakers map[string]*breaker.Breaker
-	// authKey and authValue are used to indicate to pkg.go.dev that the
-	// request is coming from the teeproxy.
-	authKey, authValue string
-}
-
-// Config contains configuration values for Server.
-type Config struct {
-	// AuthKey is the name of the header that is used by pkg.go.dev to
-	// determine if a request is coming from a trusted source.
-	AuthKey string
-	// AuthValue is the value of the header that is used by pkg.go.dev to
-	// determine that the request is coming from the teeproxy.
-	AuthValue string
-	// Hosts is the list of hosts that the teeproxy forwards requests to.
-	Hosts []string
-	// Client is the HTTP client used by the teeproxy to forward requests
-	// to the hosts.
-	Client *http.Client
-	// Rate is the rate at which requests are rate limited.
-	Rate float64
-	// Burst is the maximum burst of requests permitted.
-	Burst         int
-	BreakerConfig breaker.Config
-}
-
-// RequestEvent stores information about a godoc.org or pkg.go.dev request.
-type RequestEvent struct {
-	Host    string
-	Path    string
-	URL     string
-	Header  http.Header
-	Latency time.Duration
-	Status  int
-	Error   error
-	// IsRobot reports whether this request came from a robot.
-	// https://github.com/golang/gddo/blob/a4ebd2f/gddo-server/main.go#L152
-	IsRobot bool
-}
-
-var gddoToPkgGoDevRequest = map[string]string{
-	"/":            "/",
-	"/-/about":     "/about",
-	"/-/go":        "/std",
-	"/-/subrepo":   "/search?q=golang.org/x",
-	"/C":           "/C",
-	"/favicon.ico": "/favicon.ico",
-}
-
-// expected404s are a list of godoc.org URLs that we expected to 404 on
-// pkg.go.dev.
-var expected404s = map[string]bool{
-	"/-/bootstrap.min.css":           true,
-	"/-/bootstrap.min.js":            true,
-	"/-/bot":                         true,
-	"/-/jquery-2.0.3.min.js":         true,
-	"/-/refresh":                     true,
-	"/-/sidebar.css":                 true,
-	"/-/site.css":                    true,
-	"/-/site.js":                     true,
-	"/BingSiteAuth.xml":              true,
-	"/google3d2f3cd4cc2bb44b.html":   true,
-	"/humans.txt":                    true,
-	"/robots.txt":                    true,
-	"/third_party/jquery.timeago.js": true,
-}
-
-// statusRedBreaker is a custom HTTP status code that denotes that a request
-// cannot be handled because the circuit breaker is in the red state.
-const statusRedBreaker = 530
-
-var (
-	// keyTeeproxyStatus is a census tag for teeproxy response status codes.
-	keyTeeproxyStatus = tag.MustNewKey("teeproxy.status")
-	// keyTeeproxyHost is a census tag for hosts that teeproxy forward requests to.
-	keyTeeproxyHost = tag.MustNewKey("teeproxy.host")
-	// keyTeeproxyPath is a census tag for godoc.org paths that don't work in
-	// pkg.go.dev.
-	keyTeeproxyPath = tag.MustNewKey("teeproxy.path")
-	// teeproxyGddoLatency holds observed latency in individual teeproxy
-	// requests from godoc.org.
-	teeproxyGddoLatency = stats.Float64(
-		"go-discovery/teeproxy/gddo-latency",
-		"Latency of a teeproxy request from godoc.org.",
-		stats.UnitMilliseconds,
-	)
-	// teeproxyPkgGoDevLatency holds observed latency in individual teeproxy
-	// requests to pkg.go.dev.
-	teeproxyPkgGoDevLatency = stats.Float64(
-		"go-discovery/teeproxy/pkgGoDev-latency",
-		"Latency of a teeproxy request to pkg.go.dev.",
-		stats.UnitMilliseconds,
-	)
-	// teeproxyPkgGoDevBrokenPaths counts broken paths in pkg.go.dev that work
-	// in godoc.org
-	teeproxyPkgGoDevBrokenPaths = stats.Int64(
-		"go-discovery/teeproxy/pkgGoDev-brokenPaths",
-		"Count of paths that error in pkg.go.dev but 200 in godoc.org.",
-		stats.UnitDimensionless,
-	)
-
-	// TeeproxyGddoRequestLatencyDistribution aggregates the latency of
-	// teeproxy requests from godoc.org by status code and host.
-	TeeproxyGddoRequestLatencyDistribution = &view.View{
-		Name:        "go-discovery/teeproxy/gddo-latency",
-		Measure:     teeproxyGddoLatency,
-		Aggregation: ochttp.DefaultLatencyDistribution,
-		Description: "Teeproxy latency from godoc.org, by response status code",
-		TagKeys:     []tag.Key{keyTeeproxyStatus, keyTeeproxyHost},
-	}
-	// TeeproxyPkgGoDevRequestLatencyDistribution aggregates the latency of
-	// teeproxy requests to pkg.go.dev by status code and host.
-	TeeproxyPkgGoDevRequestLatencyDistribution = &view.View{
-		Name:        "go-discovery/teeproxy/pkgGoDev-latency",
-		Measure:     teeproxyPkgGoDevLatency,
-		Aggregation: ochttp.DefaultLatencyDistribution,
-		Description: "Teeproxy latency to pkg.go.dev, by response status code",
-		TagKeys:     []tag.Key{keyTeeproxyStatus, keyTeeproxyHost},
-	}
-	// TeeproxyGddoRequestCount counts teeproxy requests from godoc.org.
-	TeeproxyGddoRequestCount = &view.View{
-		Name:        "go-discovery/teeproxy/gddo-count",
-		Measure:     teeproxyGddoLatency,
-		Aggregation: view.Count(),
-		Description: "Count of teeproxy requests from godoc.org",
-		TagKeys:     []tag.Key{keyTeeproxyStatus, keyTeeproxyHost},
-	}
-	// TeeproxyPkgGoDevRequestCount counts teeproxy requests to pkg.go.dev.
-	TeeproxyPkgGoDevRequestCount = &view.View{
-		Name:        "go-discovery/teeproxy/pkgGoDev-count",
-		Measure:     teeproxyPkgGoDevLatency,
-		Aggregation: view.Count(),
-		Description: "Count of teeproxy requests to pkg.go.dev",
-		TagKeys:     []tag.Key{keyTeeproxyStatus, keyTeeproxyHost},
-	}
-	// TeeproxyPkgGoDevBrokenPathCount counts teeproxy requests to pkg.go.dev
-	// that return 4xx or 5xx but return 2xx or 3xx on godoc.org.
-	TeeproxyPkgGoDevBrokenPathCount = &view.View{
-		Name:        "go-discovery/teeproxy/pkgGoDev-brokenPath",
-		Measure:     teeproxyPkgGoDevBrokenPaths,
-		Aggregation: view.Count(),
-		Description: "Count of broken paths in pkg.go.dev",
-		TagKeys:     []tag.Key{keyTeeproxyStatus, keyTeeproxyHost, keyTeeproxyPath},
-	}
-)
-
-// NewServer returns a new Server struct with preconfigured settings.
-//
-// The server is rate limited and allows events up to a rate of "Rate" and
-// a burst of "Burst".
-//
-// The server also implements the circuit breaker pattern and maintains a
-// breaker for each host. Each breaker can be in one of three states: green,
-// yellow, or red.
-//
-// In the green state, the breaker remains green until it encounters a time
-// window of length "GreenInterval" where there are more than of "FailsToRed"
-// failures and a failureRatio of more than "FailureThreshold", in which case
-// the state becomes red.
-//
-// In the red state, the breaker halts all requests and waits for a timeout
-// period before shifting to the yellow state.
-//
-// In the yellow state, the breaker allows the first "SuccsToGreen" requests.
-// If any of these fail, the state reverts to red.
-// Otherwise, the state becomes green again.
-//
-// The timeout period is initially set to "MinTimeout" when the breaker shifts
-// from green to yellow. By default, the timeout period is doubled each time
-// the breaker fails to shift from the yellow state to the green state and is
-// capped at "MaxTimeout".
-func NewServer(config Config) (_ *Server, err error) {
-	defer derrors.Wrap(&err, "NewServer")
-	var breakers = make(map[string]*breaker.Breaker)
-	for _, host := range config.Hosts {
-		if host == "" {
-			return nil, errors.New("host cannot be empty")
-		}
-		b, err := breaker.New(config.BreakerConfig)
-		if err != nil {
-			return nil, err
-		}
-		breakers[host] = b
-	}
-	var client = http.DefaultClient
-	if config.Client != nil {
-		client = config.Client
-	}
-
-	authKey := config.AuthKey
-	if authKey == "" {
-		authKey = "auth-key-for-testing"
-	}
-	return &Server{
-		hosts:     config.Hosts,
-		client:    client,
-		limiter:   rate.NewLimiter(rate.Limit(config.Rate), config.Burst),
-		breakers:  breakers,
-		authKey:   authKey,
-		authValue: config.AuthValue,
-	}, nil
-}
-
-// ServeHTTP receives requests from godoc.org and forwards them to the
-// specified hosts.
-// These requests are validated and rate limited before being forwarded. Too
-// many error responses returned by pkg.go.dev will cause the server to back
-// off temporarily before trying to forward requests to the hosts again.
-// ServeHTTP will always reply with StatusOK as long as the request is a valid
-// godoc.org request, even if the request could not be processed by the hosts.
-// Instead, problems with processing the request by the hosts will logged.
-func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	// Ignore internal App Engine requests.
-	if strings.HasPrefix(r.URL.Path, "/_ah/") {
-		// Don't log requests.
-		return
-	}
-	results, status, err := s.doRequest(r)
-	if err != nil {
-		log.Infof(r.Context(), "teeproxy.Server.ServeHTTP: %v", err)
-		http.Error(w, http.StatusText(status), status)
-		return
-	}
-	log.Info(r.Context(), results)
-}
-
-func (s *Server) doRequest(r *http.Request) (results map[string]*RequestEvent, status int, err error) {
-	defer derrors.Wrap(&err, "doRequest(%q): referer=%q", r.URL.Path, r.Referer())
-	ctx := r.Context()
-	if status, err = validateTeeProxyRequest(r); err != nil {
-		return results, status, err
-	}
-	gddoEvent, err := getGddoEvent(r)
-	if err != nil {
-		return results, http.StatusBadRequest, err
-	}
-
-	results = map[string]*RequestEvent{
-		"godoc.org": gddoEvent,
-	}
-	if gddoEvent.IsRobot {
-		// Don't tee robot requests since these will use up pkg.go.dev cache
-		// space.
-		return results, http.StatusOK, nil
-	}
-	if _, ok := expected404s[gddoEvent.Path]; ok {
-		// Don't tee these requests, since we know they will 404.
-		return results, http.StatusOK, nil
-	}
-	for _, s := range []string{
-		"?import-graph",
-		"?status.png",
-		"?status.svg",
-		"api.godoc.org",
-	} {
-		if strings.Contains(gddoEvent.URL, s) {
-			// Don't tee these requests, since we know they will 404.
-			return results, http.StatusOK, nil
-		}
-	}
-	if len(s.hosts) > 0 {
-		rateLimited := !s.limiter.Allow()
-		for _, host := range s.hosts {
-			event := &RequestEvent{
-				Host: host,
-			}
-
-			if rateLimited {
-				event.Status = http.StatusTooManyRequests
-				event.Error = errors.New("rate limit exceeded")
-			} else {
-				event = s.doRequestOnHost(ctx, gddoEvent, host)
-			}
-
-			if event.Error != nil {
-				log.Errorf(r.Context(), "teeproxy.Server.doRequest(%q): %s", host, event.Error)
-			}
-			results[strings.TrimPrefix(host, "https://")] = event
-			recordTeeProxyMetric(r.Context(), host, gddoEvent.Path, gddoEvent.Status, event.Status, gddoEvent.Latency, event.Latency)
-		}
-	}
-	return results, http.StatusOK, nil
-}
-
-func (s *Server) doRequestOnHost(ctx context.Context, gddoEvent *RequestEvent, host string) *RequestEvent {
-	redirectPath := pkgGoDevPath(gddoEvent.Path)
-	event := &RequestEvent{
-		Host: host,
-		Path: redirectPath,
-	}
-
-	breaker := s.breakers[host]
-	if breaker == nil {
-		// This case should never be reached.
-		event.Status = http.StatusInternalServerError
-		event.Error = errors.New("breaker is nil")
-		return event
-	}
-
-	if !breaker.Allow() {
-		event.Status = statusRedBreaker
-		event.Error = errors.New("breaker is red")
-		return event
-	}
-
-	event = s.makePkgGoDevRequest(ctx, host, pkgGoDevPath(gddoEvent.Path))
-	if event.Error != nil {
-		return event
-	}
-	success := event.Status < http.StatusInternalServerError
-	breaker.Record(success)
-	return event
-}
-
-// validateTeeProxyRequest validates that a request to the teeproxy is allowed.
-// It will return the error code and error if a request is invalid. Otherwise,
-// it will return http.StatusOK.
-func validateTeeProxyRequest(r *http.Request) (code int, err error) {
-	defer derrors.Wrap(&err, "validateTeeProxyRequest(r)")
-	if r.Method != "POST" {
-		return http.StatusMethodNotAllowed, fmt.Errorf("%s: %q", http.StatusText(http.StatusMethodNotAllowed), r.Method)
-	}
-	ct := r.Header.Get("Content-Type")
-	if ct != "application/json; charset=utf-8" {
-		return http.StatusUnsupportedMediaType, fmt.Errorf("Content-Type %q is not supported", ct)
-	}
-	return http.StatusOK, nil
-}
-
-// pkgGoDevPath returns the corresponding path on pkg.go.dev for the given
-// godoc.org path.
-func pkgGoDevPath(gddoPath string) string {
-	redirectPath, ok := gddoToPkgGoDevRequest[gddoPath]
-	if ok {
-		return redirectPath
-	}
-	return gddoPath
-}
-
-// getGddoEvent constructs a url.URL and RequestEvent from the request.
-func getGddoEvent(r *http.Request) (gddoEvent *RequestEvent, err error) {
-	defer func() {
-		derrors.Wrap(&err, "getGddoEvent(r)")
-		if gddoEvent != nil && err != nil {
-			log.Info(r.Context(), map[string]interface{}{
-				"godoc.org": gddoEvent,
-				"tee-error": err.Error(),
-			})
-		}
-	}()
-	body, err := ioutil.ReadAll(r.Body)
-	if err != nil {
-		return nil, err
-	}
-	gddoEvent = &RequestEvent{}
-	if err := json.Unmarshal(body, gddoEvent); err != nil {
-		return nil, err
-	}
-	return gddoEvent, nil
-}
-
-// makePkgGoDevRequest makes a request to the redirectHost and redirectPath,
-// and returns a requestEvent based on the output.
-func (s *Server) makePkgGoDevRequest(ctx context.Context, redirectHost, redirectPath string) *RequestEvent {
-	redirectURL := redirectHost + redirectPath
-	event := &RequestEvent{
-		Host: redirectHost,
-		Path: redirectPath,
-		URL:  redirectURL,
-	}
-	defer derrors.Wrap(&event.Error, "makePkgGoDevRequest(%q, %q)", redirectHost, redirectPath)
-
-	req, err := http.NewRequest("GET", redirectURL, nil)
-	if err != nil {
-		event.Status = http.StatusInternalServerError
-		event.Error = err
-		return event
-	}
-	start := time.Now()
-	req.Header.Set(s.authKey, s.authValue)
-	resp, err := ctxhttp.Do(ctx, s.client, req)
-	if err != nil {
-		// Use StatusBadGateway to indicate the upstream error.
-		event.Status = http.StatusBadGateway
-		event.Error = err
-		return event
-	}
-
-	event.Status = resp.StatusCode
-	event.Latency = time.Since(start)
-	return event
-}
-
-// recordTeeProxyMetric records the latencies and counts of requests from
-// godoc.org and to pkg.go.dev, tagged with the response status code, as well
-// as any path that errors on pkg.go.dev but not on godoc.org.
-func recordTeeProxyMetric(ctx context.Context, host, path string, gddoStatus, pkgGoDevStatus int, gddoLatency, pkgGoDevLatency time.Duration) {
-	gddoL := gddoLatency.Seconds() * 1000
-	pkgGoDevL := pkgGoDevLatency.Seconds() * 1000
-
-	// Record latency.
-	stats.RecordWithTags(ctx, []tag.Mutator{
-		tag.Upsert(keyTeeproxyStatus, strconv.Itoa(pkgGoDevStatus)),
-		tag.Upsert(keyTeeproxyHost, host),
-	},
-		teeproxyGddoLatency.M(gddoL),
-		teeproxyPkgGoDevLatency.M(pkgGoDevL),
-	)
-
-	// Record path that returns 4xx or 5xx on pkg.go.dev but returns 2xx or 3xx
-	// on godoc.org, excluding rate limiter and circuit breaker errors.
-	if pkgGoDevStatus >= 400 && gddoStatus < 400 &&
-		pkgGoDevStatus != http.StatusTooManyRequests && pkgGoDevStatus != statusRedBreaker {
-		stats.RecordWithTags(ctx, []tag.Mutator{
-			tag.Upsert(keyTeeproxyStatus, strconv.Itoa(pkgGoDevStatus)),
-			tag.Upsert(keyTeeproxyHost, host),
-			tag.Upsert(keyTeeproxyPath, path),
-		},
-			teeproxyPkgGoDevBrokenPaths.M(1),
-		)
-	}
-}
diff --git a/internal/teeproxy/teeproxy_test.go b/internal/teeproxy/teeproxy_test.go
deleted file mode 100644
index 2ca0616..0000000
--- a/internal/teeproxy/teeproxy_test.go
+++ /dev/null
@@ -1,428 +0,0 @@
-// Copyright 2020 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package teeproxy
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	"github.com/google/go-cmp/cmp/cmpopts"
-	"golang.org/x/pkgsite/internal/breaker"
-)
-
-func TestPkgGoDevPath(t *testing.T) {
-	for _, test := range []struct {
-		path string
-		want string
-	}{
-		{
-			path: "/-/about",
-			want: "/about",
-		},
-		{
-			path: "/-/subrepo",
-			want: "/search?q=golang.org/x",
-		},
-		{
-			path: "/net/http",
-			want: "/net/http",
-		},
-		{
-			path: "/",
-			want: "/",
-		},
-		{
-			path: "",
-			want: "",
-		},
-	} {
-		if got := pkgGoDevPath(test.path); got != test.want {
-			t.Fatalf("pkgGoDevPath(%q) = %q; want = %q", test.path, got, test.want)
-		}
-	}
-}
-
-func TestPkgGoDevRequest(t *testing.T) {
-	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-	}))
-	defer ts.Close()
-
-	ctx := context.Background()
-	s := newTestServer(Config{})
-
-	got := s.makePkgGoDevRequest(ctx, ts.URL, "")
-	if got.Error != nil {
-		t.Fatal(got.Error)
-	}
-
-	want := &RequestEvent{
-		Host:   ts.URL,
-		URL:    ts.URL,
-		Status: http.StatusOK,
-	}
-	if diff := cmp.Diff(want, got, cmpopts.IgnoreFields(RequestEvent{}, "Latency")); diff != "" {
-		t.Fatalf("mismatch (-want +got):\n%s", diff)
-	}
-}
-
-func TestGetGddoEvent(t *testing.T) {
-	for _, test := range []struct {
-		gddoEvent *RequestEvent
-	}{
-		{
-
-			&RequestEvent{
-				Host:    "godoc.org",
-				URL:     "https://godoc.org/net/http",
-				Latency: 100,
-				Status:  200,
-			},
-		},
-	} {
-		requestBody, err := json.Marshal(test.gddoEvent)
-		if err != nil {
-			t.Fatal(err)
-		}
-		r := httptest.NewRequest("POST", "/", bytes.NewBuffer(requestBody))
-		gotEvent, err := getGddoEvent(r)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if diff := cmp.Diff(test.gddoEvent, gotEvent); diff != "" {
-			t.Fatalf("mismatch (-want +got):\n%s", diff)
-		}
-	}
-}
-
-func TestServerHandler(t *testing.T) {
-	for _, test := range []struct {
-		name         string
-		serverConfig Config
-		handler      http.Handler
-		steps        []interface{}
-	}{
-		{
-			name:         "rate limiter permits requests below cap",
-			serverConfig: Config{Rate: 20, Burst: 20},
-			handler:      alwaysHandler{http.StatusOK},
-			steps: []interface{}{
-				request{15, http.StatusOK},
-			},
-		},
-		{
-			name:         "rate limiter permits requests up to cap",
-			serverConfig: Config{Rate: 20, Burst: 20},
-			handler:      alwaysHandler{http.StatusOK},
-			steps: []interface{}{
-				request{20, http.StatusOK},
-			},
-		},
-		{
-			name:         "rate limiter drops requests over cap",
-			serverConfig: Config{Rate: 5, Burst: 5},
-			handler:      alwaysHandler{http.StatusOK},
-			steps: []interface{}{
-				request{5, http.StatusOK},
-				request{6, http.StatusTooManyRequests},
-			},
-		},
-		{
-			name:         "rate limiter permits requests after replenishing",
-			serverConfig: Config{Rate: 2, Burst: 2},
-			handler:      alwaysHandler{http.StatusOK},
-			steps: []interface{}{
-				request{2, http.StatusOK},
-				request{3, http.StatusTooManyRequests},
-				wait{1 * time.Second},
-				request{2, http.StatusOK},
-				request{3, http.StatusTooManyRequests},
-			},
-		},
-		{
-			name:         "green breaker passes requests",
-			serverConfig: Config{Rate: 100, Burst: 100},
-			handler:      alwaysHandler{http.StatusOK},
-			steps: []interface{}{
-				checkState{breaker.Green},
-				request{25, http.StatusOK},
-				checkState{breaker.Green},
-				request{25, http.StatusOK},
-				checkState{breaker.Green},
-			},
-		},
-		{
-			name: "green breaker resets failure count after interval",
-			serverConfig: Config{BreakerConfig: breaker.Config{
-				FailsToRed:    5,
-				GreenInterval: 100 * time.Millisecond,
-			}},
-			handler: alwaysHandler{http.StatusServiceUnavailable},
-			steps: []interface{}{
-				checkState{breaker.Green},
-				request{5, http.StatusServiceUnavailable},
-				checkState{breaker.Green},
-				wait{150 * time.Millisecond},
-				checkState{breaker.Green},
-				request{5, http.StatusServiceUnavailable},
-				checkState{breaker.Green},
-				request{1, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-			},
-		},
-		{
-			name: "breaker changes to red state and blocks requests",
-			serverConfig: Config{BreakerConfig: breaker.Config{
-				FailsToRed: 5,
-				MinTimeout: 1 * time.Second,
-			}},
-			handler: alwaysHandler{http.StatusServiceUnavailable},
-			steps: []interface{}{
-				checkState{breaker.Green},
-				request{6, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-				request{20, statusRedBreaker},
-				checkState{breaker.Red},
-				wait{100 * time.Millisecond},
-				request{20, statusRedBreaker},
-				checkState{breaker.Red},
-			},
-		},
-		{
-			name: "breaker changes to yellow state",
-			serverConfig: Config{BreakerConfig: breaker.Config{
-				FailsToRed: 5,
-				MinTimeout: 100 * time.Millisecond,
-			}},
-			handler: &handler{6, http.StatusServiceUnavailable, alwaysHandler{http.StatusOK}},
-			steps: []interface{}{
-				request{6, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-				request{20, statusRedBreaker},
-				checkState{breaker.Red},
-				wait{150 * time.Millisecond},
-				checkState{breaker.Yellow},
-				request{9, http.StatusOK},
-				checkState{breaker.Yellow},
-			},
-		},
-		{
-			name: "breaker changes to green state again",
-			serverConfig: Config{BreakerConfig: breaker.Config{
-				FailsToRed:   5,
-				MinTimeout:   100 * time.Millisecond,
-				SuccsToGreen: 10,
-			}},
-			handler: &handler{6, http.StatusServiceUnavailable, alwaysHandler{http.StatusOK}},
-			steps: []interface{}{
-				request{6, http.StatusServiceUnavailable},
-				request{20, statusRedBreaker},
-				wait{150 * time.Millisecond},
-				request{9, http.StatusOK},
-				checkState{breaker.Yellow},
-				request{1, http.StatusOK},
-				checkState{breaker.Green},
-				request{5, http.StatusOK},
-			},
-		},
-		{
-			name: "breaker reverts to red state and doubles timeout period on repeated failures",
-			serverConfig: Config{BreakerConfig: breaker.Config{
-				FailsToRed: 5,
-				MinTimeout: 100 * time.Millisecond,
-				MaxTimeout: 400 * time.Millisecond,
-			}},
-			handler: alwaysHandler{http.StatusServiceUnavailable},
-			steps: []interface{}{
-				request{6, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-				wait{100 * time.Millisecond},
-				checkState{breaker.Yellow},
-				request{1, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-				wait{100 * time.Millisecond},
-				checkState{breaker.Red},
-				wait{100 * time.Millisecond},
-				checkState{breaker.Yellow},
-				request{1, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-			},
-		},
-		{
-			name: "breaker timeout period does not exceed maxTimeout",
-			serverConfig: Config{BreakerConfig: breaker.Config{
-				FailsToRed: 5,
-				MinTimeout: 100 * time.Millisecond,
-				MaxTimeout: 100 * time.Millisecond,
-			}},
-			handler: alwaysHandler{http.StatusServiceUnavailable},
-			steps: []interface{}{
-				request{6, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-				wait{100 * time.Millisecond},
-				checkState{breaker.Yellow},
-				request{1, http.StatusServiceUnavailable},
-				checkState{breaker.Red},
-				wait{100 * time.Millisecond},
-				checkState{breaker.Yellow},
-			},
-		},
-	} {
-		t.Run(test.name, func(t *testing.T) {
-			mockPkgGoDevServer := httptest.NewServer(test.handler)
-			defer mockPkgGoDevServer.Close()
-			test.serverConfig.Hosts = []string{mockPkgGoDevServer.URL}
-			server := newTestServer(test.serverConfig)
-			executeSteps(t, server, mockPkgGoDevServer.URL, test.steps)
-		})
-	}
-}
-
-func executeSteps(t *testing.T, server *Server, pkgGoDevURL string, steps []interface{}) {
-	for s, step := range steps {
-		switch step := step.(type) {
-		case request:
-			for i := 0; i < step.repeat; i++ {
-				event := makePostRequest(t, server, pkgGoDevURL)
-				if event.Status != step.expectedStatus {
-					t.Errorf("step %d request %d: got status %d, want %d", s, i, event.Status, step.expectedStatus)
-				}
-			}
-		case wait:
-			time.Sleep(step.wait)
-		case checkState:
-			if server.breakers[pkgGoDevURL].State() != step.expectedState {
-				t.Errorf("step %d: got %s, want %s", s, server.breakers[pkgGoDevURL].State().String(), step.expectedState.String())
-			}
-		default:
-			panic("invalid step type")
-		}
-	}
-}
-
-// TestHandler tests that the handler struct returns
-// the correct status codes.
-func TestHandler(t *testing.T) {
-	h := &handler{5, 500, alwaysHandler{200}}
-	s := httptest.NewServer(h)
-	defer s.Close()
-
-	for i := 0; i < 5; i++ {
-		resp, err := http.PostForm(s.URL, nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if resp.StatusCode != 500 {
-			t.Errorf("request %d: got status %d, want %d", i, resp.StatusCode, 500)
-		}
-	}
-
-	for i := 0; i < 20; i++ {
-		resp, err := http.PostForm(s.URL, nil)
-		if err != nil {
-			t.Fatal(err)
-		}
-		if resp.StatusCode != 200 {
-			t.Errorf("request %d: got status %d, want %d", i, resp.StatusCode, 200)
-		}
-	}
-}
-
-func makePostRequest(t *testing.T, server *Server, pkgGoDevURL string) *RequestEvent {
-	gddoEvent := &RequestEvent{
-		Host: "godoc.org",
-		URL:  "https://godoc.org/net/http",
-	}
-	requestBody, err := json.Marshal(gddoEvent)
-	if err != nil {
-		t.Fatal(err)
-	}
-	r := httptest.NewRequest("POST", "/", bytes.NewBuffer(requestBody))
-	r.Header.Set("Content-Type", "application/json; charset=utf-8")
-	results, _, err := server.doRequest(r)
-	if err != nil || results == nil {
-		t.Fatalf("doRequest = %v: %v", results, err)
-	}
-	event := results[pkgGoDevURL]
-	if event == nil {
-		t.Fatalf("results[%q] = %v", pkgGoDevURL, event)
-	}
-	return event
-}
-
-// newTestServer is like NewServer, but with default values for easier testing.
-func newTestServer(config Config) *Server {
-	// Set default values.
-	if config.Rate <= 0 {
-		config.Rate = 50
-	}
-	if config.Burst <= 0 {
-		config.Burst = 50
-	}
-	if config.BreakerConfig.FailsToRed <= 0 {
-		config.BreakerConfig.FailsToRed = 10
-	}
-	if config.BreakerConfig.FailureThreshold <= 0 {
-		config.BreakerConfig.FailureThreshold = 0.5
-	}
-	if config.BreakerConfig.GreenInterval <= 0 {
-		config.BreakerConfig.GreenInterval = 200 * time.Millisecond
-	}
-	if config.BreakerConfig.MinTimeout <= 0 {
-		config.BreakerConfig.MinTimeout = 100 * time.Millisecond
-	}
-	if config.BreakerConfig.MaxTimeout <= 0 {
-		config.BreakerConfig.MaxTimeout = 400 * time.Millisecond
-	}
-	if config.BreakerConfig.SuccsToGreen <= 0 {
-		config.BreakerConfig.SuccsToGreen = 20
-	}
-
-	server, _ := NewServer(config)
-	return server
-}
-
-// handler returns statusCode for the first n requests
-// and uses innerHandler to serve the remaining requests.
-type handler struct {
-	n            int
-	statusCode   int
-	innerHandler http.Handler
-}
-
-func (h *handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	if h.n <= 0 {
-		h.innerHandler.ServeHTTP(w, r)
-		return
-	}
-	h.n--
-	w.WriteHeader(h.statusCode)
-}
-
-type alwaysHandler struct {
-	statusCode int
-}
-
-func (h alwaysHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	w.WriteHeader(h.statusCode)
-}
-
-type request struct {
-	repeat         int
-	expectedStatus int
-}
-
-type wait struct {
-	wait time.Duration
-}
-
-type checkState struct {
-	expectedState breaker.State
-}