feat: revisions info reporting with multi-sourced apps support

changelog/CHANGELOG.md

@@ -1,2 +1,2 @@
 ### Features
--  feat: monorepo controller  v1.0.0
+-  feat: event-reporter: report change revisions metadata in app annotations

event_reporter/reporter/app_revision.go

@@ -2,17 +2,83 @@ package reporter
 
 import (
 	"context"
-
+	"github.com/argoproj/argo-cd/v2/event_reporter/utils"
 	"github.com/argoproj/argo-cd/v2/pkg/apiclient/application"
 	appv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1"
+	log "github.com/sirupsen/logrus"
 )
 
-func (s *applicationEventReporter) getApplicationRevisionDetails(ctx context.Context, a *appv1.Application, revision string) (*appv1.RevisionMetadata, error) {
+// treats multi-sourced apps as single source and gets first revision details
+func getApplicationLegacyRevisionDetails(a *appv1.Application, revisionsMetadata *utils.AppSyncRevisionsMetadata) *appv1.RevisionMetadata {
+	_, sourceIdx := a.Spec.GetNonRefSource()
+
+	if sourceIdx == -1 { // single source app
+		sourceIdx = 0
+	}
+
+	if revisionsMetadata.SyncRevisions == nil || len(revisionsMetadata.SyncRevisions) == 0 {
+		return nil
+	}
+
+	return revisionsMetadata.SyncRevisions[sourceIdx].Metadata
+}
+
+func (s *applicationEventReporter) getRevisionsDetails(ctx context.Context, a *appv1.Application, revisions []string) ([]*utils.RevisionWithMetadata, error) {
 	project := a.Spec.GetProject()
-	return s.applicationServiceClient.RevisionMetadata(ctx, &application.RevisionMetadataQuery{
-		Name:         &a.Name,
-		AppNamespace: &a.Namespace,
-		Revision:     &revision,
-		Project:      &project,
-	})
+	rms := make([]*utils.RevisionWithMetadata, 0)
+
+	for idx, revision := range revisions {
+		// report just revision for helm sources
+		if (a.Spec.HasMultipleSources() && a.Spec.Sources[idx].IsHelm()) || (a.Spec.Source != nil && a.Spec.Source.IsHelm()) {
+			rms = append(rms, &utils.RevisionWithMetadata{
+				Revision: revision,
+			})
+			continue
+		}
+
+		rm, err := s.applicationServiceClient.RevisionMetadata(ctx, &application.RevisionMetadataQuery{
+			Name:         &a.Name,
+			AppNamespace: &a.Namespace,
+			Revision:     &revision,
+			Project:      &project,
+		})
+		if err != nil {
+			return nil, err
+		}
+		rms = append(rms, &utils.RevisionWithMetadata{
+			Revision: revision,
+			Metadata: rm,
+		})
+	}
+
+	return rms, nil
+}
+
+func (s *applicationEventReporter) getApplicationRevisionsMetadata(ctx context.Context, logCtx *log.Entry, a *appv1.Application) (*utils.AppSyncRevisionsMetadata, error) {
+	result := &utils.AppSyncRevisionsMetadata{}
+
+	if a.Status.Sync.Revision != "" || a.Status.Sync.Revisions != nil || (a.Status.History != nil && len(a.Status.History) > 0) {
+		// can be the latest revision of repository
+		operationSyncRevisionsMetadata, err := s.getRevisionsDetails(ctx, a, utils.GetOperationSyncRevisions(a))
+
+		if err != nil {
+			logCtx.WithError(err).Warnf("failed to get application(%s) sync revisions metadata, resuming", a.GetName())
+		}
+
+		if err == nil && operationSyncRevisionsMetadata != nil {
+			result.SyncRevisions = operationSyncRevisionsMetadata
+		}
+		// latest revision of repository where changes to app resource were actually made; empty if no changeRevisionі present
+		operationChangeRevisionsMetadata, err := s.getRevisionsDetails(ctx, a, utils.GetOperationChangeRevisions(a))
+
+		if err != nil {
+			logCtx.WithError(err).Warnf("failed to get application(%s) change revisions metadata, resuming", a.GetName())
+		}
+
+		if err == nil && operationChangeRevisionsMetadata != nil {
+			result.ChangeRevisions = operationChangeRevisionsMetadata
+		}
+	}
+
+	return result, nil
 }

event_reporter/reporter/application_event_reporter.go

@@ -166,14 +166,13 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 
 		// helm app hasnt revision
 		// TODO: add check if it helm application
-		parentOperationRevision := utils.GetOperationRevision(parentApplicationEntity)
-		parentRevisionMetadata, err := s.getApplicationRevisionDetails(ctx, parentApplicationEntity, parentOperationRevision)
+		parentAppSyncRevisionsMetadata, err := s.getApplicationRevisionsMetadata(ctx, logCtx, parentApplicationEntity)
 		if err != nil {
 			logCtx.WithError(err).Warn("failed to get parent application's revision metadata, resuming")
 		}
 
 		utils.SetHealthStatusIfMissing(rs)
-		err = s.processResource(ctx, *rs, parentApplicationEntity, logCtx, ts, parentDesiredManifests, appTree, manifestGenErr, a, parentRevisionMetadata, appInstanceLabelKey, trackingMethod, desiredManifests.ApplicationVersions)
+		err = s.processResource(ctx, *rs, parentApplicationEntity, logCtx, ts, parentDesiredManifests, appTree, manifestGenErr, a, parentAppSyncRevisionsMetadata, appInstanceLabelKey, trackingMethod, desiredManifests.ApplicationVersions)
 		if err != nil {
 			s.metricsServer.IncErroredEventsCounter(metrics.MetricChildAppEventType, metrics.MetricEventUnknownErrorType, a.Name)
 			return err
@@ -203,7 +202,7 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 		s.metricsServer.ObserveEventProcessingDurationHistogramDuration(a.Name, metrics.MetricParentAppEventType, reconcileDuration)
 	}
 
-	revisionMetadata, _ := s.getApplicationRevisionDetails(ctx, a, utils.GetOperationRevision(a))
+	revisionsMetadata, _ := s.getApplicationRevisionsMetadata(ctx, logCtx, a)
 	// for each resource in the application get desired and actual state,
 	// then stream the event
 	for _, rs := range a.Status.Resources {
@@ -215,7 +214,7 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 			s.metricsServer.IncCachedIgnoredEventsCounter(metrics.MetricResourceEventType, a.Name)
 			continue
 		}
-		err := s.processResource(ctx, rs, a, logCtx, ts, desiredManifests, appTree, manifestGenErr, nil, revisionMetadata, appInstanceLabelKey, trackingMethod, nil)
+		err := s.processResource(ctx, rs, a, logCtx, ts, desiredManifests, appTree, manifestGenErr, nil, revisionsMetadata, appInstanceLabelKey, trackingMethod, nil)
 		if err != nil {
 			s.metricsServer.IncErroredEventsCounter(metrics.MetricResourceEventType, metrics.MetricEventUnknownErrorType, a.Name)
 			return err
@@ -227,21 +226,22 @@ func (s *applicationEventReporter) StreamApplicationEvents(
 func (s *applicationEventReporter) getAppForResourceReporting(
 	rs appv1.ResourceStatus,
 	ctx context.Context,
+	logCtx *log.Entry,
 	a *appv1.Application,
-	revisionMetadata *appv1.RevisionMetadata,
-) (*appv1.Application, *appv1.RevisionMetadata) {
+	syncRevisionsMetadata *utils.AppSyncRevisionsMetadata,
+) (*appv1.Application, *utils.AppSyncRevisionsMetadata) {
 	if rs.Kind != "Rollout" { // for rollout it's crucial to report always correct operationSyncRevision
-		return a, revisionMetadata
+		return a, syncRevisionsMetadata
 	}
 
 	latestAppStatus, err := s.appLister.Applications(a.Namespace).Get(a.Name)
 	if err != nil {
-		return a, revisionMetadata
+		return a, syncRevisionsMetadata
 	}
 
-	revisionMetadataToReport, err := s.getApplicationRevisionDetails(ctx, latestAppStatus, utils.GetOperationRevision(latestAppStatus))
+	revisionMetadataToReport, err := s.getApplicationRevisionsMetadata(ctx, logCtx, latestAppStatus)
 	if err != nil {
-		return a, revisionMetadata
+		return a, syncRevisionsMetadata
 	}
 
 	return latestAppStatus, revisionMetadataToReport
@@ -257,7 +257,7 @@ func (s *applicationEventReporter) processResource(
 	appTree *appv1.ApplicationTree,
 	manifestGenErr bool,
 	originalApplication *appv1.Application,
-	revisionMetadata *appv1.RevisionMetadata,
+	revisionsMetadata *utils.AppSyncRevisionsMetadata,
 	appInstanceLabelKey string,
 	trackingMethod appv1.TrackingMethod,
 	applicationVersions *apiclient.ApplicationVersions,
@@ -283,12 +283,12 @@ func (s *applicationEventReporter) processResource(
 		return nil
 	}
 
-	parentApplicationToReport, revisionMetadataToReport := s.getAppForResourceReporting(rs, ctx, parentApplication, revisionMetadata)
+	parentApplicationToReport, revisionMetadataToReport := s.getAppForResourceReporting(rs, ctx, logCtx, parentApplication, revisionsMetadata)
 
-	var originalAppRevisionMetadata *appv1.RevisionMetadata = nil
+	var originalAppRevisionMetadata *utils.AppSyncRevisionsMetadata = nil
 
 	if originalApplication != nil {
-		originalAppRevisionMetadata, _ = s.getApplicationRevisionDetails(ctx, originalApplication, utils.GetOperationRevision(originalApplication))
+		originalAppRevisionMetadata, _ = s.getApplicationRevisionsMetadata(ctx, logCtx, originalApplication)
 	}
 
 	ev, err := getResourceEventPayload(parentApplicationToReport, &rs, actualState, desiredState, appTree, manifestGenErr, ts, originalApplication, revisionMetadataToReport, originalAppRevisionMetadata, appInstanceLabelKey, trackingMethod, applicationVersions)
@@ -305,7 +305,7 @@ func (s *applicationEventReporter) processResource(
 		appName = appRes.Name
 	} else {
 		utils.LogWithResourceStatus(logCtx, rs).Info("streaming resource event")
-		appName = rs.Name
+		appName = parentApplication.Name
 	}
 
 	if err := s.codefreshClient.SendEvent(ctx, appName, ev); err != nil {

event_reporter/reporter/event_payload.go

@@ -28,8 +28,8 @@ func getResourceEventPayload(
 	manifestGenErr bool,
 	ts string,
 	originalApplication *appv1.Application, // passed when rs is application
-	revisionMetadata *appv1.RevisionMetadata,
-	originalAppRevisionMetadata *appv1.RevisionMetadata, // passed when rs is application
+	revisionsMetadata *utils.AppSyncRevisionsMetadata,
+	originalAppRevisionsMetadata *utils.AppSyncRevisionsMetadata, // passed when rs is application
 	appInstanceLabelKey string,
 	trackingMethod appv1.TrackingMethod,
 	applicationVersions *apiclient.ApplicationVersions,
@@ -50,11 +50,15 @@ func getResourceEventPayload(
 
 	object := []byte(*actualState.Manifest)
 
-	if originalAppRevisionMetadata != nil && len(object) != 0 {
+	if originalAppRevisionsMetadata != nil && len(object) != 0 {
 		actualObject, err := appv1.UnmarshalToUnstructured(*actualState.Manifest)
 
 		if err == nil {
-			actualObject = utils.AddCommitDetailsToLabels(actualObject, originalAppRevisionMetadata)
+			actualObject = utils.AddCommitsDetailsToAnnotations(actualObject, originalAppRevisionsMetadata)
+			if originalApplication != nil {
+				actualObject = utils.AddCommitDetailsToLabels(actualObject, getApplicationLegacyRevisionDetails(originalApplication, originalAppRevisionsMetadata))
+			}
+
 			object, err = actualObject.MarshalJSON()
 			if err != nil {
 				return nil, fmt.Errorf("failed to marshal unstructured object: %w", err)
@@ -74,8 +78,11 @@ func getResourceEventPayload(
 			u.SetKind(rs.Kind)
 			u.SetName(rs.Name)
 			u.SetNamespace(rs.Namespace)
-			if originalAppRevisionMetadata != nil {
-				u = utils.AddCommitDetailsToLabels(u, originalAppRevisionMetadata)
+			if originalAppRevisionsMetadata != nil {
+				u = utils.AddCommitsDetailsToAnnotations(u, originalAppRevisionsMetadata)
+				if originalApplication != nil {
+					u = utils.AddCommitDetailsToLabels(u, getApplicationLegacyRevisionDetails(originalApplication, originalAppRevisionsMetadata))
+				}
 			}
 
 			object, err = u.MarshalJSON()
@@ -88,8 +95,11 @@ func getResourceEventPayload(
 			if err != nil {
 				return nil, fmt.Errorf("failed to add destination namespace to manifest: %w", err)
 			}
-			if originalAppRevisionMetadata != nil {
-				unstructuredWithNamespace = utils.AddCommitDetailsToLabels(unstructuredWithNamespace, originalAppRevisionMetadata)
+			if originalAppRevisionsMetadata != nil {
+				unstructuredWithNamespace = utils.AddCommitsDetailsToAnnotations(unstructuredWithNamespace, originalAppRevisionsMetadata)
+				if originalApplication != nil {
+					unstructuredWithNamespace = utils.AddCommitDetailsToLabels(unstructuredWithNamespace, getApplicationLegacyRevisionDetails(originalApplication, originalAppRevisionsMetadata))
+				}
 			}
 
 			object, _ = unstructuredWithNamespace.MarshalJSON()
@@ -166,10 +176,13 @@ func getResourceEventPayload(
 		TrackingMethod:        string(trackingMethod),
 	}
 
-	if revisionMetadata != nil {
-		source.CommitMessage = revisionMetadata.Message
-		source.CommitAuthor = revisionMetadata.Author
-		source.CommitDate = &revisionMetadata.Date
+	if revisionsMetadata != nil && revisionsMetadata.SyncRevisions != nil {
+		revisionMetadata := getApplicationLegacyRevisionDetails(parentApplication, revisionsMetadata)
+		if revisionMetadata != nil {
+			source.CommitMessage = revisionMetadata.Message
+			source.CommitAuthor = revisionMetadata.Author
+			source.CommitDate = &revisionMetadata.Date
+		}
 	}
 
 	if rs.Health != nil {
@@ -225,27 +238,19 @@ func (s *applicationEventReporter) getApplicationEventPayload(
 		syncFinished = a.Status.OperationState.FinishedAt
 	}
 
-	applicationSource := a.Spec.GetSource()
-	if !applicationSource.IsHelm() && (a.Status.Sync.Revision != "" || (a.Status.History != nil && len(a.Status.History) > 0)) {
-		revisionMetadata, err := s.getApplicationRevisionDetails(ctx, a, utils.GetOperationRevision(a))
+	revisionsMetadata, err := s.getApplicationRevisionsMetadata(ctx, logCtx, a)
 
-		if err != nil {
-			if !strings.Contains(err.Error(), "not found") {
-				return nil, fmt.Errorf("failed to get revision metadata: %w", err)
-			}
-
-			logCtx.Warnf("failed to get revision metadata: %s, reporting application deletion event", err.Error())
-		} else {
-			if obj.ObjectMeta.Labels == nil {
-				obj.ObjectMeta.Labels = map[string]string{}
-			}
-
-			obj.ObjectMeta.Labels["app.meta.commit-date"] = revisionMetadata.Date.Format("2006-01-02T15:04:05.000Z")
-			obj.ObjectMeta.Labels["app.meta.commit-author"] = revisionMetadata.Author
-			obj.ObjectMeta.Labels["app.meta.commit-message"] = revisionMetadata.Message
+	if err != nil {
+		if !strings.Contains(err.Error(), "not found") {
+			return nil, fmt.Errorf("failed to get revision metadata: %w", err)
 		}
+
+		logCtx.Warnf("failed to get revision metadata: %s, reporting application deletion event", err.Error())
 	}
 
+	utils.AddCommitsDetailsToAppAnnotations(obj, revisionsMetadata)
+	utils.AddCommitsDetailsToAppLabels(&obj, getApplicationLegacyRevisionDetails(&obj, revisionsMetadata))
+
 	object, err := json.Marshal(&obj)
 	if err != nil {
 		return nil, fmt.Errorf("failed to marshal application event")