Metrics: Record HTTP connections wanted and obtained (#4518)

Author: guscarreon

exchange/bidder.go

@@ -735,6 +735,7 @@ func (bidder *BidderAdapter) addClientTrace(ctx context.Context) context.Context
 		// GetConn is called before a connection is created or retrieved from an idle pool
 		GetConn: func(hostPort string) {
 			connStart = time.Now()
+			bidder.me.RecordConnectionWant()
 		},
 		// GotConn is called after a successful connection is obtained
 		GotConn: func(info httptrace.GotConnInfo) {
@@ -752,6 +753,7 @@ func (bidder *BidderAdapter) addClientTrace(ctx context.Context) context.Context
 			}
 
 			bidder.me.RecordAdapterConnections(bidder.BidderName, info.Reused, connWaitTime)
+			bidder.me.RecordConnectionGot()
 		},
 		// DNSStart is called when a DNS lookup begins.
 		DNSStart: func(info httptrace.DNSStartInfo) {

exchange/bidder_test.go

@@ -2085,6 +2085,8 @@ func TestCallRecordAdapterConnections(t *testing.T) {
 	mockMetricEngine.On("RecordAdapterConnections", expectedAdapterName, false, mock.MatchedBy(compareConnWaitTime)).Once()
 	mockMetricEngine.On("RecordOverheadTime", metrics.PreBidder, mock.Anything).Once()
 	mockMetricEngine.On("RecordBidderServerResponseTime", mock.Anything).Once()
+	mockMetricEngine.On("RecordConnectionWant").Once()
+	mockMetricEngine.On("RecordConnectionGot").Once()
 
 	// Run requestBid using an http.Client with a mock handler
 	bidder := AdaptBidder(bidderImpl, server.Client(), &config.Configuration{}, mockMetricEngine, openrtb_ext.BidderAppnexus, nil, "")

metrics/config/metrics.go

@@ -384,6 +384,18 @@ func (me *MultiMetricsEngine) RecordAdapterThrottled(adapter openrtb_ext.BidderN
 	}
 }
 
+func (me *MultiMetricsEngine) RecordConnectionWant() {
+	for _, thisME := range *me {
+		thisME.RecordConnectionWant()
+	}
+}
+
+func (me *MultiMetricsEngine) RecordConnectionGot() {
+	for _, thisME := range *me {
+		thisME.RecordConnectionGot()
+	}
+}
+
 // NilMetricsEngine implements the MetricsEngine interface where no metrics are actually captured. This is
 // used if no metric backend is configured and also for tests.
 type NilMetricsEngine struct{}
@@ -566,3 +578,9 @@ func (me *NilMetricsEngine) RecordModuleTimeout(labels metrics.ModuleLabels) {
 // RecordAdapterThrottled as a noop
 func (me *NilMetricsEngine) RecordAdapterThrottled(adapter openrtb_ext.BidderName) {
 }
+
+func (me *NilMetricsEngine) RecordConnectionWant() {
+}
+
+func (me *NilMetricsEngine) RecordConnectionGot() {
+}

metrics/go_metrics.go

@@ -18,6 +18,8 @@ type Metrics struct {
 	TMaxTimeoutCounter             metrics.Counter
 	ConnectionAcceptErrorMeter     metrics.Meter
 	ConnectionCloseErrorMeter      metrics.Meter
+	ConnectionWantCounter          metrics.Counter
+	ConnectionGotCounter           metrics.Counter
 	ImpMeter                       metrics.Meter
 	AppRequestMeter                metrics.Meter
 	NoCookieMeter                  metrics.Meter
@@ -160,6 +162,8 @@ func NewBlankMetrics(registry metrics.Registry, exchanges []string, disabledMetr
 		ConnectionCounter:              metrics.NilCounter{},
 		ConnectionAcceptErrorMeter:     blankMeter,
 		ConnectionCloseErrorMeter:      blankMeter,
+		ConnectionWantCounter:          metrics.NilCounter{},
+		ConnectionGotCounter:           metrics.NilCounter{},
 		ImpMeter:                       blankMeter,
 		AppRequestMeter:                blankMeter,
 		DebugRequestMeter:              blankMeter,
@@ -287,6 +291,8 @@ func NewMetrics(registry metrics.Registry, exchanges []openrtb_ext.BidderName, d
 	newMetrics.TMaxTimeoutCounter = metrics.GetOrRegisterCounter("tmax_timeout", registry)
 	newMetrics.ConnectionAcceptErrorMeter = metrics.GetOrRegisterMeter("connection_accept_errors", registry)
 	newMetrics.ConnectionCloseErrorMeter = metrics.GetOrRegisterMeter("connection_close_errors", registry)
+	newMetrics.ConnectionWantCounter = metrics.GetOrRegisterCounter("connection_want", registry)
+	newMetrics.ConnectionGotCounter = metrics.GetOrRegisterCounter("connection_got", registry)
 	newMetrics.ImpMeter = metrics.GetOrRegisterMeter("imps_requested", registry)
 
 	newMetrics.ImpsTypeBanner = metrics.GetOrRegisterMeter("imp_banner", registry)
@@ -670,6 +676,14 @@ func (me *Metrics) RecordConnectionClose(success bool) {
 	}
 }
 
+func (me *Metrics) RecordConnectionWant() {
+	me.ConnectionWantCounter.Inc(1)
+}
+
+func (me *Metrics) RecordConnectionGot() {
+	me.ConnectionGotCounter.Inc(1)
+}
+
 // RecordRequestTime implements a part of the MetricsEngine interface. The calling code is responsible
 // for determining the call duration.
 func (me *Metrics) RecordRequestTime(labels Labels, length time.Duration) {

metrics/go_metrics_test.go

@@ -86,6 +86,8 @@ func TestNewMetrics(t *testing.T) {
 	ensureContains(t, registry, "request_over_head_time.make-bidder-requests", m.OverheadTimer[MakeBidderRequests])
 	ensureContains(t, registry, "bidder_server_response_time_seconds", m.BidderServerResponseTimer)
 	ensureContains(t, registry, "tmax_timeout", m.TMaxTimeoutCounter)
+	ensureContains(t, registry, "connection_want", m.ConnectionWantCounter)
+	ensureContains(t, registry, "connection_got", m.ConnectionGotCounter)
 
 	for module, stages := range moduleStageNames {
 		for _, stage := range stages {

metrics/metrics.go

@@ -474,4 +474,6 @@ type MetricsEngine interface {
 	RecordModuleExecutionError(labels ModuleLabels)
 	RecordModuleTimeout(labels ModuleLabels)
 	RecordAdapterThrottled(adapterName openrtb_ext.BidderName)
+	RecordConnectionWant()
+	RecordConnectionGot()
 }

metrics/metrics_mock.go

@@ -234,3 +234,11 @@ func (me *MetricsEngineMock) RecordModuleTimeout(labels ModuleLabels) {
 func (me *MetricsEngineMock) RecordAdapterThrottled(adapterName openrtb_ext.BidderName) {
 	me.Called(adapterName)
 }
+
+func (me *MetricsEngineMock) RecordConnectionWant() {
+	me.Called()
+}
+
+func (me *MetricsEngineMock) RecordConnectionGot() {
+	me.Called()
+}

metrics/prometheus/prometheus.go

@@ -23,6 +23,8 @@ type Metrics struct {
 	connectionsClosed            prometheus.Counter
 	connectionsError             *prometheus.CounterVec
 	connectionsOpened            prometheus.Counter
+	connectionWant               prometheus.Counter
+	connectionGot                prometheus.Counter
 	cookieSync                   *prometheus.CounterVec
 	setUid                       *prometheus.CounterVec
 	impressions                  *prometheus.CounterVec
@@ -187,6 +189,14 @@ func NewMetrics(cfg config.PrometheusMetrics, disabledMetrics config.DisabledMet
 		"connections_opened",
 		"Count of successful connections opened to Prebid Server.")
 
+	metrics.connectionWant = newCounterWithoutLabels(cfg, reg,
+		"connections_want",
+		"Count number of times client trace calls GetConn.")
+
+	metrics.connectionGot = newCounterWithoutLabels(cfg, reg,
+		"connections_got",
+		"Count number of times client trace calls GotConn.")
+
 	metrics.tmaxTimeout = newCounterWithoutLabels(cfg, reg,
 		"tmax_timeout",
 		"Count of requests rejected due to Tmax timeout exceed.")
@@ -1110,3 +1120,11 @@ func (m *Metrics) RecordAdapterThrottled(adapterName openrtb_ext.BidderName) {
 		adapterLabel: strings.ToLower(string(adapterName)),
 	}).Inc()
 }
+
+func (m *Metrics) RecordConnectionWant() {
+	m.connectionWant.Inc()
+}
+
+func (m *Metrics) RecordConnectionGot() {
+	m.connectionGot.Inc()
+}

metrics/prometheus/prometheus_test.go

@@ -75,6 +75,8 @@ func TestConnectionMetrics(t *testing.T) {
 		expectedOpenedErrorCount float64
 		expectedClosedCount      float64
 		expectedClosedErrorCount float64
+		expectedConnectionWant   float64
+		expectedConnectionGot    float64
 	}{
 		{
 			description: "Open Success",
@@ -116,6 +118,20 @@ func TestConnectionMetrics(t *testing.T) {
 			expectedClosedCount:      0,
 			expectedClosedErrorCount: 1,
 		},
+		{
+			description: "connection-want",
+			testCase: func(m *Metrics) {
+				m.RecordConnectionWant()
+			},
+			expectedConnectionWant: 1,
+		},
+		{
+			description: "connection-got",
+			testCase: func(m *Metrics) {
+				m.RecordConnectionGot()
+			},
+			expectedConnectionGot: 1,
+		},
 	}
 
 	for _, test := range testCases {
@@ -135,6 +151,10 @@ func TestConnectionMetrics(t *testing.T) {
 			test.expectedClosedErrorCount, prometheus.Labels{
 				connectionErrorLabel: connectionCloseError,
 			})
+		assertCounterValue(t, test.description, "connectionWant", m.connectionWant,
+			test.expectedConnectionWant)
+		assertCounterValue(t, test.description, "connectionGot", m.connectionGot,
+			test.expectedConnectionGot)
 	}
 }