conn rename

Author: danehlim

agent/vendor/github.com/aws/amazon-ecs-agent/ecs-agent/acs/session/session.go

@@ -102,8 +102,8 @@ type session struct {
 	lastConnectedTime              time.Time
 	lastDisconnectedTime           time.Time
 	firstACSConnectionTime         time.Time
-	dpeFailureTracker                *metrics.FailureTracker
-	acsFailureTracker                *metrics.FailureTracker
+	dpeFailureTracker              *metrics.FailureTracker
+	acsConnFailureTracker          *metrics.FailureTracker
 }
 
 // SessionOption configures optional behavior on the ACS session.
@@ -115,10 +115,10 @@ func WithDPEFailureTracker(dpeFailureTracker *metrics.FailureTracker) SessionOpt
 	return func(s *session) { s.dpeFailureTracker = dpeFailureTracker }
 }
 
-// WithACSFailureTracker sets the FailureTracker used to track ACS
+// WithACSConnFailureTracker sets the FailureTracker used to track ACS
 // connection failures across retry attempts.
-func WithACSFailureTracker(acsFailureTracker *metrics.FailureTracker) SessionOption {
-	return func(s *session) { s.acsFailureTracker = acsFailureTracker }
+func WithACSConnFailureTracker(acsConnFailureTracker *metrics.FailureTracker) SessionOption {
+	return func(s *session) { s.acsConnFailureTracker = acsConnFailureTracker }
 }
 
 // NewSession creates a new Session.
@@ -201,11 +201,11 @@ func (s *session) Start(ctx context.Context) error {
 	// The below is required to trigger the first connection to ACS.
 	sendEmptyMessageOnChannel(connectToACS)
 
-	// Start DiscoverPollEndpoint and ACS connectivity emit loops so that the
+	// Start DiscoverPollEndpoint and ACS connectivity failure emit loops so that the
 	// corresponding metrics have the ability to be emitted while the below
 	// continuous loop to establish connection with ACS is in progress.
 	go s.dpeFailureTracker.StartEmitLoop(ctx)
-	go s.acsFailureTracker.StartEmitLoop(ctx)
+	go s.acsConnFailureTracker.StartEmitLoop(ctx)
 
 	// Loop continuously until context is closed/canceled.
 	for {
@@ -271,7 +271,7 @@ func (s *session) startSessionOnce(ctx context.Context) error {
 	acsEndpoint, err := s.ecsClient.DiscoverPollEndpoint(s.containerInstanceARN)
 	if err != nil {
 		s.dpeFailureTracker.RecordFailure()
-		s.acsFailureTracker.RecordFailure()
+		s.acsConnFailureTracker.RecordFailure()
 		logger.Error("ACS: Unable to discover poll endpoint", logger.Fields{
 			"containerInstanceARN": s.containerInstanceARN,
 			field.Error:            err,
@@ -297,7 +297,7 @@ func (s *session) startSessionOnce(ctx context.Context) error {
 	// Metric created for determining whether ACS connection is successful or not
 	s.metricsFactory.New(metrics.ACSSessionFailureCallName).Done(err)
 	if err != nil {
-		s.acsFailureTracker.RecordFailure()
+		s.acsConnFailureTracker.RecordFailure()
 		logger.Error("Failed to connect to ACS", logger.Fields{
 			"containerInstanceARN": s.containerInstanceARN,
 			field.Error:            err,
@@ -320,7 +320,7 @@ func (s *session) startSessionOnce(ctx context.Context) error {
 
 	// Connection to ACS was successful. Moving forward, rely on ACS to send credentials to Agent at its own cadence
 	// and make sure Agent does not force ACS to send credentials for any subsequent reconnects to ACS.
-	s.acsFailureTracker.RecordSuccess()
+	s.acsConnFailureTracker.RecordSuccess()
 	logger.Info("Connected to ACS endpoint",
 		logger.Fields{
 			"containerInstanceARN": s.containerInstanceARN,

agent/vendor/github.com/aws/amazon-ecs-agent/ecs-agent/tcs/handler/handler.go

@@ -1491,7 +1491,7 @@ func TestSessionCallsAddUpdateRequestHandlers(t *testing.T) {
 	assert.True(t, addUpdateRequestHandlersCalled)
 }
 
-func TestDPEAndACSFailureTrackerTracking(t *testing.T) {
+func TestDPEAndACSConnFailureTrackerTracking(t *testing.T) {
 	testCases := []struct {
 		name             string
 		setupMocks       func(*mock_ecs.MockECSClient, *mock_wsclient.MockClientFactory, *mock_wsclient.MockClientServer)
@@ -1552,18 +1552,18 @@ func TestDPEAndACSFailureTrackerTracking(t *testing.T) {
 				metricsfactory.DPEFailureTrackerFailureMetricName,
 				metricsfactory.NewNopEntryFactory(),
 			)
-			acsFailureTracker := metricsfactory.NewFailureTracker(
-				metricsfactory.ACSFailureTrackerFailureMetricName,
+			acsConnFailureTracker := metricsfactory.NewFailureTracker(
+				metricsfactory.ACSConnFailureTrackerFailureMetricName,
 				metricsfactory.NewNopEntryFactory(),
 			)
 
 			s := session{
-				containerInstanceARN: testconst.ContainerInstanceARN,
-				ecsClient:            ecsClient,
-				clientFactory:        mockClientFactory,
-				metricsFactory:       metricsfactory.NewNopEntryFactory(),
-				dpeFailureTracker:      dpeFailureTracker,
-				acsFailureTracker:      acsFailureTracker,
+				containerInstanceARN:  testconst.ContainerInstanceARN,
+				ecsClient:             ecsClient,
+				clientFactory:         mockClientFactory,
+				metricsFactory:        metricsfactory.NewNopEntryFactory(),
+				dpeFailureTracker:     dpeFailureTracker,
+				acsConnFailureTracker: acsConnFailureTracker,
 			}
 
 			err := s.startSessionOnce(context.Background())
@@ -1573,7 +1573,7 @@ func TestDPEAndACSFailureTrackerTracking(t *testing.T) {
 				assert.NoError(t, err)
 			}
 			assert.Equal(t, tc.expectDPEFailing, dpeFailureTracker.IsFailing())
-			assert.Equal(t, tc.expectACSFailing, acsFailureTracker.IsFailing())
+			assert.Equal(t, tc.expectACSFailing, acsConnFailureTracker.IsFailing())
 		})
 	}
 }

ecs-agent/acs/session/session.go

@@ -76,16 +76,16 @@ type telemetrySession struct {
 	doctor                        *doctor.Doctor
 	ecsClient                     TcsEcsClient
 	lastDisconnectedTime          time.Time
-	tcsFailureTracker               *metrics.FailureTracker
+	tcsConnFailureTracker         *metrics.FailureTracker
 }
 
 // TelemetrySessionOption configures optional behavior on the TCS session.
 type TelemetrySessionOption func(*telemetrySession)
 
-// WithTCSFailureTracker sets the FailureTracker used to track TCS
+// WithTCSConnFailureTracker sets the FailureTracker used to track TCS
 // connection failures across retry attempts.
-func WithTCSFailureTracker(tcsFailureTracker *metrics.FailureTracker) TelemetrySessionOption {
-	return func(s *telemetrySession) { s.tcsFailureTracker = tcsFailureTracker }
+func WithTCSConnFailureTracker(tcsConnFailureTracker *metrics.FailureTracker) TelemetrySessionOption {
+	return func(session *telemetrySession) { session.tcsConnFailureTracker = tcsConnFailureTracker }
 }
 
 func NewTelemetrySession(
@@ -140,10 +140,10 @@ func NewTelemetrySession(
 
 // Start runs in for loop to start telemetry session with exponential backoff
 func (session *telemetrySession) Start(ctx context.Context) error {
-	// Start TCS connectivity emit loops so that the corresponding metric
+	// Start TCS connectivity failure emit loops so that the corresponding metric
 	// has the ability to be emitted while the below continuous loop to
 	// establish connection with TCS is in progress.
-	go session.tcsFailureTracker.StartEmitLoop(ctx)
+	go session.tcsConnFailureTracker.StartEmitLoop(ctx)
 
 	backoff := retry.NewExponentialBackoff(backoffMin, backoffMax, jitterMultiple, multiple)
 	for {
@@ -181,7 +181,7 @@ func (session *telemetrySession) StartTelemetrySession(ctx context.Context) erro
 
 	endpoint, err := session.getTelemetryEndpoint()
 	if err != nil {
-		session.tcsFailureTracker.RecordFailure()
+		session.tcsConnFailureTracker.RecordFailure()
 		return err
 	}
 
@@ -194,7 +194,7 @@ func (session *telemetrySession) StartTelemetrySession(ctx context.Context) erro
 	if session.deregisterInstanceEventStream != nil {
 		err := session.deregisterInstanceEventStream.Subscribe(deregisterContainerInstanceHandler, client.Disconnect)
 		if err != nil {
-			session.tcsFailureTracker.RecordFailure()
+			session.tcsConnFailureTracker.RecordFailure()
 			return err
 		}
 		defer session.deregisterInstanceEventStream.Unsubscribe(deregisterContainerInstanceHandler)
@@ -205,7 +205,7 @@ func (session *telemetrySession) StartTelemetrySession(ctx context.Context) erro
 		session.disconnectTimeout,
 		session.disconnectJitterMax)
 	if err != nil {
-		session.tcsFailureTracker.RecordFailure()
+		session.tcsConnFailureTracker.RecordFailure()
 		logger.Error("Error connecting to TCS", logger.Fields{
 			field.Error: err,
 		})
@@ -218,7 +218,7 @@ func (session *telemetrySession) StartTelemetrySession(ctx context.Context) erro
 			session.GetLastDisconnectedTime()).Milliseconds()).Done(nil)
 	}
 	defer disconnectTimer.Stop()
-	session.tcsFailureTracker.RecordSuccess()
+	session.tcsConnFailureTracker.RecordSuccess()
 	logger.Info("Connected to TCS endpoint")
 	// start a timer and listens for tcs heartbeats/acks. The timer is reset when
 	// we receive a heartbeat from the server or when a published metrics message

ecs-agent/acs/session/session_test.go

@@ -800,9 +800,9 @@ func TestPeriodicDisconnectonTCSClient(t *testing.T) {
 	closeSocket(closeWS)
 }
 
-func TestTCSFailureTrackerRecordsFailure(t *testing.T) {
-	tcsFailureTracker := metrics.NewFailureTracker(
-		metrics.TCSFailureTrackerFailureMetricName,
+func TestTCSConnFailureTrackerRecordsFailure(t *testing.T) {
+	tcsConnFailureTracker := metrics.NewFailureTracker(
+		metrics.TCSConnectivityFailureMetricName,
 		metrics.NewNopEntryFactory(),
 	)
 
@@ -832,31 +832,31 @@ func TestTCSFailureTrackerRecordsFailure(t *testing.T) {
 		instanceStatusMessages,
 		emptyDoctor,
 		testecsclient,
-		WithTCSFailureTracker(tcsFailureTracker),
+		WithTCSConnFailureTracker(tcsConnFailureTracker),
 	)
 
 	err := session.StartTelemetrySession(context.Background())
 	assert.Error(t, err)
-	assert.True(t, tcsFailureTracker.IsFailing())
+	assert.True(t, tcsConnFailureTracker.IsFailing())
 }
 
-func TestTCSFailureTrackerRecordsSuccess(t *testing.T) {
+func TestTCSConnFailureTrackerRecordsSuccess(t *testing.T) {
 	closeWS := make(chan []byte)
 	server, _, _, _, err := wsmock.GetMockServer(closeWS)
 	assert.NoError(t, err)
 	server.StartTLS()
 	defer server.Close()
 	defer close(closeWS)
 
-	tcsFailureTracker := metrics.NewFailureTracker(
-		metrics.TCSFailureTrackerFailureMetricName,
+	tcsConnFailureTracker := metrics.NewFailureTracker(
+		metrics.TCSConnectivityFailureMetricName,
 		metrics.NewNopEntryFactory(),
 	)
 
 	ctx, cancel := context.WithCancel(context.Background())
 
 	// Start in a failing state to verify later that RecordSuccess resets it.
-	tcsFailureTracker.RecordFailure()
+	tcsConnFailureTracker.RecordFailure()
 
 	// Call cancel upfront to ensure that TCS client does not serve traffic
 	// indefinitely once TCS connection is successful.
@@ -887,10 +887,10 @@ func TestTCSFailureTrackerRecordsSuccess(t *testing.T) {
 		instanceStatusMessages,
 		emptyDoctor,
 		testecsclient,
-		WithTCSFailureTracker(tcsFailureTracker),
+		WithTCSConnFailureTracker(tcsConnFailureTracker),
 	)
 
 	err = session.StartTelemetrySession(ctx)
 	assert.ErrorIs(t, err, context.Canceled)
-	assert.False(t, tcsFailureTracker.IsFailing())
+	assert.False(t, tcsConnFailureTracker.IsFailing())
 }