remove the metrics package

Recording every sent and received packet in OpenCensus is quite expensive.
Arguably, the metrics needs depend on the application, so that's where the
implementation of a metrics collector should live anyway.

integrationtests/self/self_suite_test.go

@@ -23,7 +23,6 @@ import (
 	"github.com/lucas-clemente/quic-go"
 	"github.com/lucas-clemente/quic-go/internal/utils"
 	"github.com/lucas-clemente/quic-go/logging"
-	"github.com/lucas-clemente/quic-go/metrics"
 	"github.com/lucas-clemente/quic-go/qlog"
 
 	. "github.com/onsi/ginkgo"
@@ -84,11 +83,10 @@ func (b *syncedBuffer) Reset() {
 }
 
 var (
-	logFileName   string // the log file set in the ginkgo flags
-	logBufOnce    sync.Once
-	logBuf        *syncedBuffer
-	enableQlog    bool
-	enableMetrics bool
+	logFileName string // the log file set in the ginkgo flags
+	logBufOnce  sync.Once
+	logBuf      *syncedBuffer
+	enableQlog  bool
 
 	tlsConfig          *tls.Config
 	tlsConfigLongChain *tls.Config
@@ -101,8 +99,6 @@ var (
 func init() {
 	flag.StringVar(&logFileName, "logfile", "", "log file")
 	flag.BoolVar(&enableQlog, "qlog", false, "enable qlog")
-	// metrics won't be accessible anywhere, but it's useful to exercise the code
-	flag.BoolVar(&enableMetrics, "metrics", false, "enable metrics")
 }
 
 var _ = BeforeSuite(func() {
@@ -136,9 +132,8 @@ var _ = BeforeSuite(func() {
 		NextProtos: []string{alpn},
 	}
 
-	var qlogTracer, metricsTracer logging.Tracer
 	if enableQlog {
-		qlogTracer = qlog.NewTracer(func(p logging.Perspective, connectionID []byte) io.WriteCloser {
+		tracer = qlog.NewTracer(func(p logging.Perspective, connectionID []byte) io.WriteCloser {
 			role := "server"
 			if p == logging.PerspectiveClient {
 				role = "client"
@@ -151,17 +146,6 @@ var _ = BeforeSuite(func() {
 			return utils.NewBufferedWriteCloser(bw, f)
 		})
 	}
-	if enableMetrics {
-		metricsTracer = metrics.NewTracer()
-	}
-
-	if enableQlog && enableMetrics {
-		tracer = logging.NewMultiplexedTracer(qlogTracer, metricsTracer)
-	} else if enableQlog {
-		tracer = qlogTracer
-	} else if enableMetrics {
-		tracer = metricsTracer
-	}
 })
 
 func generateCA() (*x509.Certificate, *rsa.PrivateKey, error) {

integrationtests/self/tracer_test.go

@@ -9,24 +9,74 @@ import (
 	"io/ioutil"
 	mrand "math/rand"
 	"net"
+	"time"
 
 	"github.com/lucas-clemente/quic-go"
 	"github.com/lucas-clemente/quic-go/internal/protocol"
 	"github.com/lucas-clemente/quic-go/internal/utils"
 	"github.com/lucas-clemente/quic-go/logging"
-	"github.com/lucas-clemente/quic-go/metrics"
 	"github.com/lucas-clemente/quic-go/qlog"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
 )
 
+type customTracer struct{}
+
+var _ logging.Tracer = &customTracer{}
+
+func (t *customTracer) TracerForConnection(p logging.Perspective, odcid logging.ConnectionID) logging.ConnectionTracer {
+	return &customConnTracer{}
+}
+func (t *customTracer) SentPacket(net.Addr, *logging.Header, logging.ByteCount, []logging.Frame) {}
+func (t *customTracer) DroppedPacket(net.Addr, logging.PacketType, logging.ByteCount, logging.PacketDropReason) {
+}
+
+type customConnTracer struct{}
+
+var _ logging.ConnectionTracer = &customConnTracer{}
+
+func (t *customConnTracer) StartedConnection(local, remote net.Addr, version logging.VersionNumber, srcConnID, destConnID logging.ConnectionID) {
+}
+func (t *customConnTracer) ClosedConnection(logging.CloseReason)                     {}
+func (t *customConnTracer) SentTransportParameters(*logging.TransportParameters)     {}
+func (t *customConnTracer) ReceivedTransportParameters(*logging.TransportParameters) {}
+func (t *customConnTracer) RestoredTransportParameters(*logging.TransportParameters) {}
+func (t *customConnTracer) SentPacket(hdr *logging.ExtendedHeader, size logging.ByteCount, ack *logging.AckFrame, frames []logging.Frame) {
+}
+
+func (t *customConnTracer) ReceivedVersionNegotiationPacket(*logging.Header, []logging.VersionNumber) {
+}
+func (t *customConnTracer) ReceivedRetry(*logging.Header) {}
+func (t *customConnTracer) ReceivedPacket(hdr *logging.ExtendedHeader, size logging.ByteCount, frames []logging.Frame) {
+}
+func (t *customConnTracer) BufferedPacket(logging.PacketType) {}
+func (t *customConnTracer) DroppedPacket(logging.PacketType, logging.ByteCount, logging.PacketDropReason) {
+}
+
+func (t *customConnTracer) UpdatedMetrics(rttStats *logging.RTTStats, cwnd, bytesInFlight logging.ByteCount, packetsInFlight int) {
+}
+
+func (t *customConnTracer) LostPacket(logging.EncryptionLevel, logging.PacketNumber, logging.PacketLossReason) {
+}
+func (t *customConnTracer) UpdatedCongestionState(logging.CongestionState)                     {}
+func (t *customConnTracer) UpdatedPTOCount(value uint32)                                       {}
+func (t *customConnTracer) UpdatedKeyFromTLS(logging.EncryptionLevel, logging.Perspective)     {}
+func (t *customConnTracer) UpdatedKey(generation logging.KeyPhase, remote bool)                {}
+func (t *customConnTracer) DroppedEncryptionLevel(logging.EncryptionLevel)                     {}
+func (t *customConnTracer) DroppedKey(logging.KeyPhase)                                        {}
+func (t *customConnTracer) SetLossTimer(logging.TimerType, logging.EncryptionLevel, time.Time) {}
+func (t *customConnTracer) LossTimerExpired(logging.TimerType, logging.EncryptionLevel)        {}
+func (t *customConnTracer) LossTimerCanceled()                                                 {}
+func (t *customConnTracer) Debug(string, string)                                               {}
+func (t *customConnTracer) Close()                                                             {}
+
 var _ = Describe("Handshake tests", func() {
 	addTracers := func(pers protocol.Perspective, conf *quic.Config) *quic.Config {
 		enableQlog := mrand.Int()%3 != 0
-		enableMetrics := mrand.Int()%3 != 0
+		enableCustomTracer := mrand.Int()%3 != 0
 
-		fmt.Fprintf(GinkgoWriter, "%s using qlog: %t, metrics: %t\n", pers, enableQlog, enableMetrics)
+		fmt.Fprintf(GinkgoWriter, "%s using qlog: %t, custom: %t\n", pers, enableQlog, enableCustomTracer)
 
 		var tracers []logging.Tracer
 		if enableQlog {
@@ -39,8 +89,8 @@ var _ = Describe("Handshake tests", func() {
 				return utils.NewBufferedWriteCloser(bufio.NewWriter(&bytes.Buffer{}), ioutil.NopCloser(nil))
 			}))
 		}
-		if enableMetrics {
-			tracers = append(tracers, metrics.NewTracer())
+		if enableCustomTracer {
+			tracers = append(tracers, &customTracer{})
 		}
 		c := conf.Clone()
 		c.Tracer = logging.NewMultiplexedTracer(tracers...)