add a multiplexer for the logging.Tracer

logging/interface.go

@@ -79,7 +79,11 @@ const (
 
 // A Tracer traces events.
 type Tracer interface {
+	// TracerForServer requests a new tracer for a connection that was accepted by the server.
+	// If nil is returned, tracing will be disabled for this connection.
 	TracerForServer(odcid ConnectionID) ConnectionTracer
+	// TracerForServer requests a new tracer for a connection that was dialed by the client.
+	// If nil is returned, tracing will be disabled for this connection.
 	TracerForClient(odcid ConnectionID) ConnectionTracer
 }
 

logging/mock_tracer_test.go

@@ -0,0 +1,62 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: github.com/lucas-clemente/quic-go/logging (interfaces: Tracer)
+
+// Package logging is a generated GoMock package.
+package logging
+
+import (
+	gomock "github.com/golang/mock/gomock"
+	protocol "github.com/lucas-clemente/quic-go/internal/protocol"
+	reflect "reflect"
+)
+
+// MockTracer is a mock of Tracer interface
+type MockTracer struct {
+	ctrl     *gomock.Controller
+	recorder *MockTracerMockRecorder
+}
+
+// MockTracerMockRecorder is the mock recorder for MockTracer
+type MockTracerMockRecorder struct {
+	mock *MockTracer
+}
+
+// NewMockTracer creates a new mock instance
+func NewMockTracer(ctrl *gomock.Controller) *MockTracer {
+	mock := &MockTracer{ctrl: ctrl}
+	mock.recorder = &MockTracerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use
+func (m *MockTracer) EXPECT() *MockTracerMockRecorder {
+	return m.recorder
+}
+
+// TracerForClient mocks base method
+func (m *MockTracer) TracerForClient(arg0 protocol.ConnectionID) ConnectionTracer {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TracerForClient", arg0)
+	ret0, _ := ret[0].(ConnectionTracer)
+	return ret0
+}
+
+// TracerForClient indicates an expected call of TracerForClient
+func (mr *MockTracerMockRecorder) TracerForClient(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TracerForClient", reflect.TypeOf((*MockTracer)(nil).TracerForClient), arg0)
+}
+
+// TracerForServer mocks base method
+func (m *MockTracer) TracerForServer(arg0 protocol.ConnectionID) ConnectionTracer {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "TracerForServer", arg0)
+	ret0, _ := ret[0].(ConnectionTracer)
+	return ret0
+}
+
+// TracerForServer indicates an expected call of TracerForServer
+func (mr *MockTracerMockRecorder) TracerForServer(arg0 interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TracerForServer", reflect.TypeOf((*MockTracer)(nil).TracerForServer), arg0)
+}

logging/mockgen.go

@@ -1,3 +1,4 @@
 package logging
 
 //go:generate sh -c "mockgen -package logging -destination mock_connection_tracer_test.go github.com/lucas-clemente/quic-go/logging ConnectionTracer"
+//go:generate sh -c "mockgen -package logging -destination mock_tracer_test.go github.com/lucas-clemente/quic-go/logging Tracer"

logging/multiplex.go

@@ -5,15 +5,52 @@ import (
 	"time"
 )
 
+type tracerMultiplexer struct {
+	tracers []Tracer
+}
+
+var _ Tracer = &tracerMultiplexer{}
+
+// NewMultiplexedTracer creates a new tracer that multiplexes all events to multiple tracers.
+func NewMultiplexedTracer(tracers ...Tracer) Tracer {
+	if len(tracers) == 0 {
+		return nil
+	}
+	if len(tracers) == 1 {
+		return tracers[1]
+	}
+	return &tracerMultiplexer{tracers}
+}
+
+func (m *tracerMultiplexer) TracerForServer(odcid ConnectionID) ConnectionTracer {
+	var connTracers []ConnectionTracer
+	for _, t := range m.tracers {
+		if ct := t.TracerForServer(odcid); ct != nil {
+			connTracers = append(connTracers, ct)
+		}
+	}
+	return newConnectionMultiplexer(connTracers...)
+}
+
+func (m *tracerMultiplexer) TracerForClient(odcid ConnectionID) ConnectionTracer {
+	var connTracers []ConnectionTracer
+	for _, t := range m.tracers {
+		if ct := t.TracerForClient(odcid); ct != nil {
+			connTracers = append(connTracers, ct)
+		}
+	}
+	return newConnectionMultiplexer(connTracers...)
+}
+
 type connTracerMultiplexer struct {
 	tracers []ConnectionTracer
 }
 
 var _ ConnectionTracer = &connTracerMultiplexer{}
 
-func NewConnectionMultiplexer(tracers ...ConnectionTracer) ConnectionTracer {
+func newConnectionMultiplexer(tracers ...ConnectionTracer) ConnectionTracer {
 	if len(tracers) == 0 {
-		panic("no tracers")
+		return nil
 	}
 	if len(tracers) == 1 {
 		return tracers[0]

logging/multiplex_test.go

@@ -7,9 +7,62 @@ import (
 	"github.com/lucas-clemente/quic-go/internal/wire"
 
 	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
 )
 
 var _ = Describe("Tracing", func() {
+	Context("Tracer", func() {
+		var (
+			tracer   Tracer
+			tr1, tr2 *MockTracer
+		)
+
+		BeforeEach(func() {
+			tr1 = NewMockTracer(mockCtrl)
+			tr2 = NewMockTracer(mockCtrl)
+			tracer = NewMultiplexedTracer(tr1, tr2)
+		})
+
+		It("multiplexes the TracerForServer call", func() {
+			tr1.EXPECT().TracerForServer(ConnectionID{1, 2, 3})
+			tr2.EXPECT().TracerForServer(ConnectionID{1, 2, 3})
+			tracer.TracerForServer(ConnectionID{1, 2, 3})
+		})
+
+		It("multiplexes the TracerForClient call", func() {
+			tr1.EXPECT().TracerForClient(ConnectionID{1, 2, 3})
+			tr2.EXPECT().TracerForClient(ConnectionID{1, 2, 3})
+			tracer.TracerForClient(ConnectionID{1, 2, 3})
+		})
+
+		It("uses multiple connection tracers", func() {
+			ctr1 := NewMockConnectionTracer(mockCtrl)
+			ctr2 := NewMockConnectionTracer(mockCtrl)
+			tr1.EXPECT().TracerForClient(ConnectionID{1, 2, 3}).Return(ctr1)
+			tr2.EXPECT().TracerForClient(ConnectionID{1, 2, 3}).Return(ctr2)
+			tr := tracer.TracerForClient(ConnectionID{1, 2, 3})
+			ctr1.EXPECT().LossTimerCanceled()
+			ctr2.EXPECT().LossTimerCanceled()
+			tr.LossTimerCanceled()
+		})
+
+		It("handles tracers that return a nil ConnectionTracer", func() {
+			ctr1 := NewMockConnectionTracer(mockCtrl)
+			tr1.EXPECT().TracerForClient(ConnectionID{1, 2, 3}).Return(ctr1)
+			tr2.EXPECT().TracerForClient(ConnectionID{1, 2, 3})
+			tr := tracer.TracerForClient(ConnectionID{1, 2, 3})
+			ctr1.EXPECT().LossTimerCanceled()
+			tr.LossTimerCanceled()
+		})
+
+		It("returns nil when all tracers return a nil ConnectionTracer", func() {
+			tr1.EXPECT().TracerForClient(ConnectionID{1, 2, 3})
+			tr2.EXPECT().TracerForClient(ConnectionID{1, 2, 3})
+			Expect(tracer.TracerForClient(ConnectionID{1, 2, 3})).To(BeNil())
+		})
+	})
+
+	Context("Connection Tracer", func() {
 		var (
 			tracer ConnectionTracer
 			tr1    *MockConnectionTracer
@@ -19,7 +72,7 @@ var _ = Describe("Tracing", func() {
 		BeforeEach(func() {
 			tr1 = NewMockConnectionTracer(mockCtrl)
 			tr2 = NewMockConnectionTracer(mockCtrl)
-		tracer = NewConnectionMultiplexer(tr1, tr2)
+			tracer = newConnectionMultiplexer(tr1, tr2)
 		})
 
 		It("trace the ConnectionStarted event", func() {
@@ -156,4 +209,5 @@ var _ = Describe("Tracing", func() {
 			tr2.EXPECT().Close()
 			tracer.Close()
 		})
+	})
 })