refactor record.go, address linting items

Signed-off-by: Eric Pickard <piceri@github.com>

Author: piceri

internal/controller/controller.go

@@ -48,8 +48,8 @@ type ttlCache interface {
 }
 
 type deploymentRecordPoster interface {
-	PostOne(ctx context.Context, record *deploymentrecord.DeploymentRecord) error
-	PostCluster(ctx context.Context, records []*deploymentrecord.DeploymentRecord, cluster string) ([]byte, error)
+	PostOne(ctx context.Context, record *deploymentrecord.Record) error
+	PostCluster(ctx context.Context, records []*deploymentrecord.Record, cluster string) ([]byte, error)
 }
 
 type podMetadataAggregator interface {

internal/controller/controller_integration_test.go

@@ -26,23 +26,23 @@ import (
 
 type mockRecordPoster struct {
 	mu      sync.Mutex
-	records []*deploymentrecord.DeploymentRecord
+	records []*deploymentrecord.Record
 	err     error // to simulate failures
 }
 
-func (m *mockRecordPoster) PostOne(_ context.Context, record *deploymentrecord.DeploymentRecord) error {
+func (m *mockRecordPoster) PostOne(_ context.Context, record *deploymentrecord.Record) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.records = append(m.records, record)
 	return m.err
 }
 
-func (m *mockRecordPoster) PostCluster(_ context.Context, _ []*deploymentrecord.DeploymentRecord, _ string) ([]byte, error) {
+func (m *mockRecordPoster) PostCluster(_ context.Context, _ []*deploymentrecord.Record, _ string) ([]byte, error) {
 	return nil, nil
 }
 
 // Helper that allows tests to read captured records safely.
-func (m *mockRecordPoster) getRecords() []*deploymentrecord.DeploymentRecord {
+func (m *mockRecordPoster) getRecords() []*deploymentrecord.Record {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	return slices.Clone(m.records)

internal/controller/controller_test.go

@@ -33,14 +33,14 @@ type mockPoster struct {
 	clusterErr         error
 }
 
-func (m *mockPoster) PostOne(_ context.Context, _ *deploymentrecord.DeploymentRecord) error {
+func (m *mockPoster) PostOne(_ context.Context, _ *deploymentrecord.Record) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.calls++
 	return m.lastErr
 }
 
-func (m *mockPoster) PostCluster(_ context.Context, records []*deploymentrecord.DeploymentRecord, _ string) ([]byte, error) {
+func (m *mockPoster) PostCluster(_ context.Context, records []*deploymentrecord.Record, _ string) ([]byte, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.clusterCalls++

internal/controller/reporting.go

@@ -117,7 +117,7 @@ func (c *Controller) processEvent(ctx context.Context, event PodEvent) error {
 	return lastErr
 }
 
-func (c *Controller) processSyncEvents(ctx context.Context, syncClusterPods []interface{}) error {
+func (c *Controller) processSyncEvents(ctx context.Context, syncClusterPods []any) error {
 	syncRecords := c.makeSyncRecords(ctx, syncClusterPods)
 	if len(syncRecords) == 0 {
 		slog.Info("No sync records to post")
@@ -139,7 +139,7 @@ func (c *Controller) processSyncEvents(ctx context.Context, syncClusterPods []in
 		)
 		return fmt.Errorf("failed to post sync cluster records: %w", err)
 	}
-	var deploymentRecords deploymentrecord.DeploymentRecordsClusterResp
+	var deploymentRecords deploymentrecord.RecordsClusterResp
 	err = json.Unmarshal(respBody, &deploymentRecords)
 	if err != nil {
 		slog.Error("Failed to unmarshall response",
@@ -157,9 +157,9 @@ func (c *Controller) processSyncEvents(ctx context.Context, syncClusterPods []in
 	return nil
 }
 
-func (c *Controller) makeSyncRecords(ctx context.Context, syncClusterPods []interface{}) []*deploymentrecord.DeploymentRecord {
+func (c *Controller) makeSyncRecords(ctx context.Context, syncClusterPods []any) []*deploymentrecord.Record {
 	seenSyncRecords := make(map[string]bool)
-	var syncRecords []*deploymentrecord.DeploymentRecord
+	var syncRecords []*deploymentrecord.Record
 	for _, p := range syncClusterPods {
 		pod, ok := p.(*corev1.Pod)
 		if !ok {
@@ -219,7 +219,7 @@ func (c *Controller) makeSyncRecords(ctx context.Context, syncClusterPods []inte
 	return syncRecords
 }
 
-func (c *Controller) fillCaches(deploymentRecords deploymentrecord.DeploymentRecordsClusterResp) {
+func (c *Controller) fillCaches(deploymentRecords deploymentrecord.RecordsClusterResp) {
 	slog.Info("Filling caches after posting sync cluster records")
 	// Fill observedDeployments cache with successful digests
 	for _, r := range deploymentRecords.DeploymentRecords {
@@ -348,7 +348,7 @@ func (c *Controller) recordContainer(ctx context.Context, pod *corev1.Pod, conta
 	return nil
 }
 
-func (c *Controller) buildRecord(pod *corev1.Pod, container corev1.Container, eventType, workloadName string, aggPodMetadata *metadata.AggregatePodMetadata) *deploymentrecord.DeploymentRecord {
+func (c *Controller) buildRecord(pod *corev1.Pod, container corev1.Container, eventType, workloadName string, aggPodMetadata *metadata.AggregatePodMetadata) *deploymentrecord.Record {
 	dn := getARDeploymentName(pod, container, c.cfg.Template, workloadName)
 	digest := getContainerDigest(pod, container.Name)
 

internal/controller/reporting_test.go

@@ -3,6 +3,7 @@ package controller
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -120,7 +121,7 @@ func TestProcessSyncEvents_EmptyPodList(t *testing.T) {
 	poster := &mockPoster{}
 	ctrl := newTestController(poster)
 
-	err := ctrl.processSyncEvents(context.Background(), []interface{}{})
+	err := ctrl.processSyncEvents(context.Background(), []any{})
 	require.NoError(t, err)
 	assert.Equal(t, 0, poster.getPostClusterCalls(), "PostCluster should not be called for empty pod list")
 }
@@ -130,28 +131,28 @@ func TestProcessSyncEvents_HappyPath(t *testing.T) {
 	digest := "sha256:abc123"
 	unknownDigest := "sha256:notfound999"
 	unauthorizedDigest := "sha256:unauthorized999"
-	clusterResp := deploymentrecord.DeploymentRecordsClusterResp{
+	clusterResp := deploymentrecord.RecordsClusterResp{
 		TotalCount: 1,
-		DeploymentRecords: []*deploymentrecord.DeploymentRecordResp{{
-			DeploymentRecord: deploymentrecord.DeploymentRecord{
-				DeploymentRecordBase: deploymentrecord.DeploymentRecordBase{
+		DeploymentRecords: []*deploymentrecord.RecordResp{{
+			Record: deploymentrecord.Record{
+				BaseRecord: deploymentrecord.BaseRecord{
 					DeploymentName: "default/test-deploy/app",
 					Digest:         digest,
 				},
 			},
 		}},
-		Errors: []*deploymentrecord.DeploymentRecordErrorResp{
+		Errors: []*deploymentrecord.RecordErrorResp{
 			{
-				DeploymentRecord: deploymentrecord.DeploymentRecord{
-					DeploymentRecordBase: deploymentrecord.DeploymentRecordBase{
+				Record: deploymentrecord.Record{
+					BaseRecord: deploymentrecord.BaseRecord{
 						Digest: unknownDigest,
 					},
 				},
 				Cause: "not_found",
 			},
 			{
-				DeploymentRecord: deploymentrecord.DeploymentRecord{
-					DeploymentRecordBase: deploymentrecord.DeploymentRecordBase{
+				Record: deploymentrecord.Record{
+					BaseRecord: deploymentrecord.BaseRecord{
 						Digest: unauthorizedDigest,
 					},
 				},
@@ -166,10 +167,10 @@ func TestProcessSyncEvents_HappyPath(t *testing.T) {
 	ctrl := newTestController(poster)
 	ctrl.workloadResolver = &mockResolver{name: "test-deploy"}
 
-	err = ctrl.processSyncEvents(context.Background(), []interface{}{
-		makePod("app", "test-deploy-abc123", digest, "ReplicaSet"),
-		makePod("unknown", "test-deploy-abc123", unknownDigest, "ReplicaSet"),
-		makePod("unauthorized", "test-deploy-abc123", unauthorizedDigest, "ReplicaSet"),
+	err = ctrl.processSyncEvents(context.Background(), []any{
+		makeTestPod("app", "test-deploy-abc123", digest, "ReplicaSet"),
+		makeTestPod("unknown", "test-deploy-abc456", unknownDigest, "ReplicaSet"),
+		makeTestPod("unauthorized", "test-deploy-abc789", unauthorizedDigest, "Job"),
 	})
 	require.NoError(t, err)
 	assert.Equal(t, 1, poster.getPostClusterCalls(), "PostCluster should be called once")
@@ -196,9 +197,9 @@ func TestProcessSyncEvents_DedupeContainers(t *testing.T) {
 	ctrl := newTestController(poster)
 	ctrl.workloadResolver = &mockResolver{name: "test-deploy"}
 
-	pod := makePod("app", "test-deploy-abc123", digest, "ReplicaSet")
+	pod := makeTestPod("app", "test-deploy-abc123", digest, "ReplicaSet")
 
-	err := ctrl.processSyncEvents(context.Background(), []interface{}{pod, pod})
+	err := ctrl.processSyncEvents(context.Background(), []any{pod, pod})
 	require.NoError(t, err)
 	assert.Equal(t, 1, poster.getPostClusterCalls(), "PostCluster should be called once")
 	assert.Equal(t, 1, poster.clusterRecordCount, "PostCluster should receive only 1 record")
@@ -211,9 +212,9 @@ func TestProcessSyncEvents_PostCluster404(t *testing.T) {
 	}
 	ctrl := newTestController(poster)
 	ctrl.workloadResolver = &mockResolver{name: "test-deploy"}
-	pod := makePod("app", "test-deploy-abc123", "sha256:abc123", "ReplicaSet")
+	pod := makeTestPod("app", "test-deploy-abc123", "sha256:abc123", "ReplicaSet")
 
-	err := ctrl.processSyncEvents(context.Background(), []interface{}{pod})
+	err := ctrl.processSyncEvents(context.Background(), []any{pod})
 	require.NoError(t, err, "ClusterNoRepositoriesError should not propagate")
 	assert.Equal(t, 1, poster.getPostClusterCalls())
 
@@ -226,19 +227,19 @@ func TestProcessSyncEvents_PostCluster404(t *testing.T) {
 func TestProcessSyncEvents_PostCluster500(t *testing.T) {
 	t.Parallel()
 	poster := &mockPoster{
-		clusterErr: fmt.Errorf("server error"),
+		clusterErr: errors.New("server error"),
 	}
 	ctrl := newTestController(poster)
 	ctrl.workloadResolver = &mockResolver{name: "test-deploy"}
-	pod := makePod("app", "test-deploy-abc123", "sha256:abc123", "ReplicaSet")
+	pod := makeTestPod("app", "test-deploy-abc123", "sha256:abc123", "ReplicaSet")
 
-	err := ctrl.processSyncEvents(context.Background(), []interface{}{pod})
+	err := ctrl.processSyncEvents(context.Background(), []any{pod})
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "failed to post sync cluster records")
 	assert.Equal(t, 1, poster.getPostClusterCalls())
 }
 
-func makePod(containerName string, parentName string, digest string, parentKind string) *corev1.Pod {
+func makeTestPod(containerName string, parentName string, digest string, parentKind string) *corev1.Pod {
 	return &corev1.Pod{
 		ObjectMeta: metav1.ObjectMeta{
 			Name:      "test-pod",

pkg/deploymentrecord/client.go

@@ -165,6 +165,8 @@ func (c *ClientError) Unwrap() error {
 	return c.err
 }
 
+// ClusterNoRepositoriesError represents a 404 response from the cluster endpoint
+// indicating no repositories were found for the given cluster.
 type ClusterNoRepositoriesError struct {
 	err error
 }
@@ -195,27 +197,27 @@ func (n *NoArtifactError) Unwrap() error {
 
 // PostOne posts a single deployment record to the GitHub deployment
 // records API.
-func (c *Client) PostOne(ctx context.Context, record *DeploymentRecord) error {
+func (c *Client) PostOne(ctx context.Context, record *Record) error {
 	if record == nil {
 		return errors.New("record cannot be nil")
 	}
 
-	singleUrl := fmt.Sprintf("%s/orgs/%s/artifacts/metadata/deployment-record", c.baseURL, c.org)
+	singleURL := fmt.Sprintf("%s/orgs/%s/artifacts/metadata/deployment-record", c.baseURL, c.org)
 
 	body, err := buildRequestBody(record)
 	if err != nil {
 		return fmt.Errorf("failed to marshal record: %w", err)
 	}
 
-	respBody, statusCode, lastErr := c.postWithRetry(ctx, singleUrl, body)
+	respBody, statusCode, lastErr := c.postWithRetry(ctx, singleURL, body)
 
 	var clientErr *ClientError
 	switch {
 	case errors.As(lastErr, &clientErr):
 		dtmetrics.PostDeploymentRecordClientError.Inc()
 		slog.Warn("client error, aborting",
 			"status_code", statusCode,
-			"url", singleUrl,
+			"url", singleURL,
 			"resp_msg", string(respBody),
 		)
 		return fmt.Errorf("client error: %w", lastErr)
@@ -244,28 +246,28 @@ func (c *Client) PostOne(ctx context.Context, record *DeploymentRecord) error {
 
 // PostCluster sends a full cluster state of records to GitHub deployment
 // records cluster API.
-func (c *Client) PostCluster(ctx context.Context, records []*DeploymentRecord, cluster string) ([]byte, error) {
-	if len(records) <= 0 {
+func (c *Client) PostCluster(ctx context.Context, records []*Record, cluster string) ([]byte, error) {
+	if len(records) == 0 {
 		slog.Debug("Records is empty, skipping")
 		return nil, nil
 	}
 
-	clusterUrl := fmt.Sprintf("%s/orgs/%s/artifacts/metadata/deployment-record/cluster/%s", c.baseURL, c.org, url.PathEscape(cluster))
+	clusterURL := fmt.Sprintf("%s/orgs/%s/artifacts/metadata/deployment-record/cluster/%s", c.baseURL, c.org, url.PathEscape(cluster))
 
 	body, err := buildClusterRequestBody(records)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal records: %w", err)
 	}
 
-	respBody, statusCode, lastErr := c.postWithRetry(ctx, clusterUrl, body)
+	respBody, statusCode, lastErr := c.postWithRetry(ctx, clusterURL, body)
 
 	var clientErr *ClientError
 	switch {
 	case errors.As(lastErr, &clientErr):
 		dtmetrics.PostDeploymentRecordClientError.Inc()
 		slog.Warn("client error, aborting",
 			"status_code", statusCode,
-			"url", clusterUrl,
+			"url", clusterURL,
 			"resp_msg", string(respBody),
 		)
 		return nil, fmt.Errorf("client error: %w", lastErr)
@@ -274,7 +276,7 @@ func (c *Client) PostCluster(ctx context.Context, records []*DeploymentRecord, c
 		return respBody, nil
 	case statusCode == 404:
 		dtmetrics.PostDeploymentRecordUnknownArtifact.Inc()
-		return nil, &ClusterNoRepositoriesError{err: fmt.Errorf("no repositories found")}
+		return nil, &ClusterNoRepositoriesError{err: errors.New("no repositories found")}
 	default:
 		dtmetrics.PostDeploymentRecordHardFail.Inc()
 		slog.Error("all retries exhausted",
@@ -286,7 +288,7 @@ func (c *Client) PostCluster(ctx context.Context, records []*DeploymentRecord, c
 	}
 }
 
-func (c *Client) postWithRetry(ctx context.Context, url string, body []byte) ([]byte, int, error) {
+func (c *Client) postWithRetry(ctx context.Context, targetURL string, body []byte) ([]byte, int, error) {
 	bodyReader := bytes.NewReader(body)
 	var lastErr error
 	// The first attempt is not a retry!
@@ -306,7 +308,7 @@ func (c *Client) postWithRetry(ctx context.Context, url string, body []byte) ([]
 		// Reset reader position for retries
 		bodyReader.Reset(body)
 
-		req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, bodyReader)
+		req, err := http.NewRequestWithContext(ctx, http.MethodPost, targetURL, bodyReader)
 		if err != nil {
 			return nil, 0, fmt.Errorf("failed to create request: %w", err)
 		}
@@ -363,7 +365,7 @@ func (c *Client) postWithRetry(ctx context.Context, url string, body []byte) ([]
 					"retry-after", resp.Header.Get("Retry-After"),
 					"x-ratelimit-remaining", resp.Header.Get("X-Ratelimit-Remaining"),
 					"retry_delay", retryDelay.Seconds(),
-					"url", url,
+					"url", targetURL,
 					"resp_msg", string(respBody),
 				)
 				lastErr = fmt.Errorf("rate limited, attempt %d", attempt)
@@ -377,7 +379,7 @@ func (c *Client) postWithRetry(ctx context.Context, url string, body []byte) ([]
 			slog.Debug("retriable error",
 				"attempt", attempt,
 				"status_code", resp.StatusCode,
-				"url", url,
+				"url", targetURL,
 				"resp_msg", string(respBody),
 			)
 			lastErr = fmt.Errorf("server error, attempt %d", attempt)
@@ -463,29 +465,29 @@ func parseRateLimitDelay(resp *http.Response) time.Duration {
 
 // buildRequestBody adds return_records=false to a deployment record request body
 // which results in a minimal response payload.
-func buildRequestBody(record *DeploymentRecord) ([]byte, error) {
+func buildRequestBody(record *Record) ([]byte, error) {
 	return json.Marshal(struct {
-		DeploymentRecord
+		Record
 		ReturnRecords bool `json:"return_records"`
 	}{
-		DeploymentRecord: *record,
-		ReturnRecords:    false,
+		Record:        *record,
+		ReturnRecords: false,
 	})
 }
 
-// buildClusterRequestBody count the total records, builds DeploymentRecords,
+// buildClusterRequestBody count the total records, builds ClusterRecordsBody,
 // and returns []byte.
-func buildClusterRequestBody(records []*DeploymentRecord) ([]byte, error) {
-	if len(records) <= 0 {
+func buildClusterRequestBody(records []*Record) ([]byte, error) {
+	if len(records) == 0 {
 		return nil, nil
 	}
-	deploymentRecords := []DeploymentRecordBase{}
+	deploymentRecords := []BaseRecord{}
 
 	for _, r := range records {
-		deploymentRecords = append(deploymentRecords, r.DeploymentRecordBase)
+		deploymentRecords = append(deploymentRecords, r.BaseRecord)
 	}
 
-	return json.Marshal(DeploymentRecords{
+	return json.Marshal(ClusterRecordsBody{
 		LogicalEnvironment:  records[0].LogicalEnvironment,
 		PhysicalEnvironment: records[0].PhysicalEnvironment,
 		PartialSuccess:      true,