Skip to content
CAI
Software that uses CAICheck a score

argoproj/argo-cd

58.4

Adequate · 13 November 2026

112k

lines of production code

Go

with JavaScript, Lua

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

3scale resource health checks

Added health-check scripts for 3scale APIManager, ActiveDoc, Application, ApplicationAuth, Backend, CustomPolicyDefinition, DeveloperAccount, DeveloperUser, OpenAPI, Product, ProxyConfigPromote, and Tenant resources. These scripts evaluate the status conditions and deployment states of each resource to report Healthy, Degraded, Suspended, or Progressing states, providing users with clearer visibility into the operational health of their 3scale components.

_resource\_customizations/apps.3scale.net, resource\customizations/capabilities.3scale.net · high confidence

Add ApplicationSet Controller documentation to CLI docs generation

The documentation generation tool now includes the ApplicationSet Controller commands alongside the existing CLI, Server, Repo Server, and Dex commands, ensuring that ApplicationSet-specific usage information is generated and available in the user documentation.

tools · high confidence

Add Crossplane and Upbound resource health checks

Adds Lua-based health check scripts for Crossplane and Upbound resources to correctly report their status in Argo CD. The new logic handles resources that lack status conditions (such as Composition, ProviderConfig, and StoreConfig) by marking them Healthy, ensures ManagedResourceDefinitions with Inactive state are not flagged as degraded, and properly reports Degraded status when async operations or sync conditions fail.

_resource\customizations/\.crossplane.io · high confidence_

Add Helm Config Management Plugin example

Added a new example in \examples/plugins/helm\ that demonstrates how to configure Argo CD to use Helm as a Config Management Plugin (CMP). This includes the necessary shell scripts (\generate.sh\, \get-parameters.sh\) to handle Helm template generation and parameter discovery, a \plugin.yaml\ defining the CMP specification, and a Kubernetes deployment patch to install the required Helm, jq, and yq tools into the Argo CD repo-server sidecar.

examples/plugins/helm · high confidence

Add breadcrumb navigation and TOC label customization

The documentation theme now displays a breadcrumb trail above the page title, showing the navigation hierarchy via the \page.ancestors\ variable, and allows customization of the Table of Contents label (defaulting to "Table of Contents") through a new language partial.

overrides · high confidence

Add custom health check for Knative Serving Service resources

Users can now see accurate health status for Knative Serving Service resources. A new Lua-based health check evaluates the service's conditions (ConfigurationsReady, RoutesReady, Ready) to report Healthy, Degraded, or Progressing states, providing specific error messages when conditions are not met.

_resource\customizations/serving.knative.dev · high confidence

Add custom resource actions and health checks for Flux resources

Users can now manually reconcile, suspend, and resume Flux resources (HelmRelease, ImageRepository, ImageUpdateAutomation, Kustomization, and Alert) directly from the Argo CD UI, and see accurate health statuses (Healthy, Progressing, Degraded, Suspended) for these custom resources. This is achieved by adding Lua-based action and health scripts for each resource type, along with corresponding test data and validation tests.

(repo-wide) · high confidence

Add health check for BanzaiCloud KafkaCluster resources

Users managing BanzaiCloud KafkaCluster custom resources now have a dedicated health check that accurately reflects the cluster's operational state. The new Lua script evaluates the resource status to report 'Healthy' when all brokers are in sync and Cruise Control is ready, 'Progressing' during rolling upgrades or reconciliation, and 'Degraded' if broker configurations are out of sync. This ensures that Argo CD correctly tracks the lifecycle and health of Kafka clusters, preventing false error reports during normal update operations.

_resource\customizations/kafka.banzaicloud.io · high confidence

Add health check for ClusterResourceSet

Users can now see the health status of ClusterResourceSet resources in the UI. The new health check script evaluates the 'ResourcesApplied' condition: it reports 'Healthy' when the condition is True, 'Degraded' with the error message when False, and 'Progressing' otherwise.

_resource\customizations/addons.cluster.x-k8s.io · high confidence

Add health check for Crossplane ClusterStackInstall resources

Users deploying Crossplane ClusterStackInstall resources will now see accurate health status in the UI. A new Lua health script evaluates the \Ready\ condition within the resource's \status.conditionedStatus\, reporting 'Healthy' when the condition is True and 'Progressing' otherwise, with the specific reason message included.

_resource\customizations/stacks.crossplane.io · high confidence

Add health check for Iamrole resources

Users can now see the reconciliation status of Iamrole resources managed by the IAM Manager operator. The new health check script evaluates the resource's status field, reporting 'Healthy' when the role is Ready, 'Degraded' with specific error details (such as limit reached or policy violations) when reconciliation fails, and 'Progressing' while waiting for the role to be created or updated.

_resource\customizations/iammanager.keikoproj.io · high confidence

Add health check for OpenShift DeploymentConfig

Users can now see the health status of OpenShift DeploymentConfig resources in the UI. A new Lua health-check script evaluates the \Available\ and \Progressing\ conditions (including the \NewReplicationControllerAvailable\ reason) to report Healthy, Progressing, or Degraded states, ensuring the status accurately reflects whether the replication controller has successfully rolled out.

_resource\customizations/apps.openshift.io · high confidence

Add health check for Pulumi Stack resources

Users can now see the health status of Pulumi Stack resources in their cluster. This change introduces a Lua-based health check script that maps the Stack's Kubernetes conditions (Ready, Reconciling, Stalled) to Argo CD health statuses (Healthy, Progressing, Degraded), providing clear messages about whether a stack is up to date, currently being processed, or stalled due to failures.

_resource\customizations/pulumi.com · high confidence

Add health check for SealedSecret resources

Users can now see the health status of SealedSecret resources in the UI. The new health check script evaluates the \Synced\ condition in the resource's status, reporting 'Healthy' when synced, 'Degraded' with the specific error message when sync fails, and 'Progressing' while waiting for decryption.

_resource\customizations/bitnami.com · high confidence

Add health check logic for Numaplane PipelineRollout resources

This change introduces a new Lua-based health check script for the \PipelineRollout\ resource in the \numaplane.numaproj.io\ API group. The script evaluates the resource's status conditions and phase to determine if the rollout is Healthy, Progressing, Degraded, or Paused, providing specific messages for each state (e.g., 'Not yet reconciled', 'Pipeline Failed', 'Progressive upgrade failed'). Corresponding test cases are added to validate these health statuses against sample resource definitions.

_resource\customizations/numaplane.numaproj.io/PipelineRollout · high confidence

Add health check support for cert-manager ClusterIssuer resources

Users can now see the health status of cert-manager ClusterIssuer resources in the UI. The system evaluates the ClusterIssuer's Ready condition: it reports as Healthy when the condition is True, Degraded when False, and Progressing when no status is present.

_resource\customizations/cert-manager.io/ClusterIssuer · high confidence

Add health checks and cluster actions for CloudNativePG resources

This update introduces custom health checks and cluster management actions for CloudNativePG resources in Argo CD. For the Cluster CRD, health is now determined by the \status.phase\ and specific annotations like \cnpg.io/reconciliationLoop\ and \cnpg.io/hibernation\, mapping states such as 'Switchover in progress' to Degraded and hibernation to Suspended. Corresponding actions allow users to perform cluster operations directly from the UI, including rolling restarts, configuration reloads, promoting replicas to primary, and managing reconciliation suspension or cluster hibernation. Additionally, new health checks are provided for the Database and Backup CRDs, accurately reflecting their reconciliation status and backup phase (e.g., Healthy for completed backups, Degraded for failures).

_resource\customizations/postgresql.cnpg.io · high confidence

Add health checks and push actions for PushSecret resources

This change introduces resource customizations for the External Secrets \PushSecret\ kind, enabling Argo CD to monitor its status and trigger manual syncs. A new health check script (\health.lua\) evaluates the \PushSecret\'s \Ready\ condition to report Healthy, Degraded, or Progressing states in the UI. Additionally, a 'push' action is added, which allows users to manually force a sync by adding a \force-sync\ annotation; this action is automatically disabled if the \refreshInterval\ is set to zero to prevent no-op operations.

_resource\customizations/external-secrets.io/PushSecret · high confidence

Add health checks and refresh actions for ExternalSecret resources

This update adds resource customizations for \external-secrets.io/ExternalSecret\ objects, enabling Argo CD to display their health status (Healthy, Degraded, or Progressing) based on the \Ready\ condition in the resource status. It also introduces a 'Refresh' action that allows users to manually trigger a secret sync by adding a \force-sync\ annotation, while intelligently disabling this action when the \refreshInterval\ is set to zero and the \refreshPolicy\ is not \OnChange\ to prevent no-op operations.

_resource\customizations/external-secrets.io/ExternalSecret · high confidence

Add health checks and terminate action for AnalysisRun and Experiment resources

This change introduces resource customizations for Argo Rollouts AnalysisRun and Experiment resources. For AnalysisRun, a new 'terminate' action is added, allowing users to stop a running analysis; the action is automatically disabled when the run is in a terminal state (Successful, Failed, Error, Inconclusive) or if the spec already has terminate set. Health checks are implemented for both AnalysisRun and Experiment, mapping their status phases (Pending, Running, Successful, Failed, Error, Inconclusive) to UI statuses (Progressing, Healthy, Degraded, Unknown) and providing descriptive messages, including support for custom status messages when available.

_resource\customizations/argoproj.io/AnalysisRun · high confidence

Add health checks for Altinity ClickHouse and ClickHouseKeeper installations

Users can now see accurate health status for Altinity ClickHouse and ClickHouseKeeper custom resources. The new Lua health scripts map the operator's status field to standard health states: 'Completed' is reported as Healthy, 'InProgress' as Progressing, and any other status (such as 'Failed') as Degraded. This provides clearer visibility into the lifecycle of these installations within the dashboard.

_resource\_customizations/clickhouse-keeper.altinity.com, resource\customizations/clickhouse.altinity.com · high confidence

Add health checks for Astra.netapp.io custom resources

This change introduces Lua-based health-check scripts and corresponding test data for several Astra.netapp.io Custom Resource Definitions, including AppVault, Application, Backup, ExecHook, ExecHooksRun, ResourceBackup, and ResticVolumeBackup. Users will now see accurate health statuses (Healthy, Degraded, Suspended, or Progressing) for these resources in the UI, reflecting their actual operational state rather than defaulting to unknown or progressing.

_resource\_customizations/astra.netapp.io, resource\customizations/kafka.strimzi.io · high confidence

Add health checks for CephCluster, CephObjectStore, and ObjectBucketClaim

This change introduces Lua-based health scripts for three Rook-Ceph and ObjectBucket resources, enabling the platform to report their operational status. For CephCluster, the script evaluates the Ceph health state (HEALTH\_OK, HEALTH\_WARN, HEALTH\_ERR) and the cluster state (Created, Connected, Error) to determine if the resource is Healthy, Degraded, or Progressing. For CephObjectStore, health is determined by the status phase (Ready, Failure, Pending). For ObjectBucketClaim, health is based on the phase (Bound, Failed, Pending). Test data and test definitions are included to validate these logic paths.

_resource\customizations/ceph.rook.io · high confidence

Add health checks for Cluster API resources

Introduces Lua-based health check scripts for Cluster API resources (Cluster, Machine, MachineDeployment, MachineHealthCheck, and MachinePool) to provide accurate status reporting in the UI. The Cluster health check distinguishes between normal provisioning (Progressing) and actual failures (Degraded) by evaluating the status phase and Ready condition severity, while Machine, MachineDeployment, and MachinePool checks map their respective phases (e.g., Running, Scaling, Failed) to health statuses. MachineHealthCheck health is determined by comparing current healthy machines against expected counts.

_resource\_customizations/cluster.x-k8s.io, resource\customizations/gateway.networking.k8s.io · high confidence

Add health checks for Coralogix Alert and RecordingRuleGroupSet resources

Users can now see the health status of Coralogix Alert and RecordingRuleGroupSet custom resources in their cluster. This change introduces Lua-based health scripts that evaluate the \RemoteSynced\ condition on these resources, reporting them as Healthy, Degraded, or Progressing based on whether the remote resource has been successfully synced or if an error occurred.

_resource\customizations/coralogix.com · high confidence

Add health checks for Crossplane Provider resources

Users can now see the health status of Crossplane Provider resources in the UI. A new Lua script evaluates the Provider's status conditions: if both 'Installed' and 'Healthy' conditions are true, the resource is marked as Healthy; otherwise, it is marked as Degraded. If the status is missing or conditions are not yet set, the resource shows as Progressing.

_resource\customizations/pkg.crossplane.io · high confidence

Add health checks for Crossplane and Upbound resources

This change introduces Lua-based health check scripts for Crossplane and Upbound resources, ensuring accurate status reporting in the UI. For Crossplane resources, the health script distinguishes between Healthy, Progressing, and Degraded states by checking specific conditions like Ready, Healthy, and LastAsyncOperation, while also handling kinds that do not have status conditions (e.g., Composition, ProviderConfig). For Upbound resources, the health script similarly evaluates conditions such as Ready, Synced, and LastAsyncOperation to determine health, with special handling for ProviderConfig and ProviderConfigUsage kinds that may not have status conditions. The implementation includes test cases to validate these health checks against various resource states.

(repo-wide) · high confidence

Add health checks for DNSSDServiceInstance resources

Users can now see the operational status of DNSSDServiceInstance resources in the dashboard. A new health check script evaluates the resource's status conditions—specifically Adopted, Advertised, and Discoverable—to report whether the instance is Healthy, Progressing, Degraded, or in an Unknown state, providing clear messages for issues like advertisement errors or discovery failures.

_resource\customizations/proclaim.dogmatiq.io · high confidence

Add health checks for FlinkDeployment and FlinkSessionJob

This change introduces Lua-based health-check scripts for the \flink.apache.org\ API group, enabling the UI to accurately reflect the status of Flink resources. For \FlinkDeployment\, the script reports Healthy when the job is deployed or suspended (specifically handling the pre-deployment suspended state to avoid false Progressing signals), Progressing during deployment, and Degraded on errors. For \FlinkSessionJob\, the script maps job states to Healthy (Running/Finished), Progressing (Reconciling/Created), Suspended, or Degraded (Failed/Error). Test data and validation files are included to verify these behaviors across v0.1.x and v1.x Flink operator versions.

_resource\customizations/flink.apache.org · high confidence

Add health checks for GKE ManagedCertificate resources

Users managing GKE ManagedCertificate resources will now see accurate health status indicators in the UI. The new Lua health script evaluates the certificate's status: it reports 'Healthy' when all certificates are active, 'Degraded' if any certificate fails to provision (status 'FailedNotVisible'), and 'Progressing' while certificates are still being provisioned.

_resource\customizations/networking.gke.io · high confidence

Add health checks for GitOps Promoter resources

Argo CD now displays accurate health statuses for GitOps Promoter resources, including ArgoCDCommitStatus, ChangeTransferPolicy, ClusterScmProvider, CommitStatus, and GitCommitStatus. The new Lua-based health scripts evaluate the Ready condition, observed generation, and specific resource states (such as active/proposed commit SHAs for ChangeTransferPolicy or environment validation phases for GitCommitStatus) to report Healthy, Progressing, or Degraded states. This provides users with immediate visibility into the reconciliation status and any errors affecting promotion strategies and commit validations.

_resource\customizations/promoter.argoproj.io · high confidence

Add health checks for Grafana operator resources

Added health-check scripts and test data for the Grafana operator's Custom Resource Definitions (Grafana, GrafanaDashboard, GrafanaDatasource, and GrafanaFolder). These checks allow Argo CD to accurately report the deployment status of Grafana instances and their associated dashboards, datasources, and folders, including handling negative-polarity conditions such as FolderUIDMismatch.

_resource\customizations/grafana.integreatly.org · high confidence

Add health checks for ISBServiceRollout and NumaflowControllerRollout resources

This change introduces Lua-based health check scripts and corresponding test data for the \ISBServiceRollout\ and \NumaflowControllerRollout\ Numaplane Custom Resource Definitions (CRDs). The health logic evaluates the resource status to report 'Healthy', 'Progressing', or 'Degraded' states, specifically handling conditions such as failed child resources, progressive upgrade failures, and pending updates. This ensures that Argo CD can accurately reflect the operational status of these Numaplane-managed resources in the UI.

_resource\customizations/numaplane.numaproj.io/ISBServiceRollout · high confidence

Add health checks for IngressController resources

Users can now see the health status of OpenShift IngressController resources. A new Lua health-check script evaluates the resource's status conditions, reporting 'Healthy' when available, 'Progressing' during rollout or initialization, and 'Degraded' if critical conditions indicate issues. This change is accompanied by test data and validation tests to ensure accurate status reporting.

_resource\customizations/operator.openshift.io · high confidence

Add health checks for KRO ResourceGraphDefinition and Instance resources

This change introduces Lua-based health-check scripts for KRO (kro.run) custom resources, specifically \ResourceGraphDefinition\ and generic KRO instances (e.g., \WebApplication\). The scripts evaluate the \status.conditions\ and \status.state\ fields to report resource health as Healthy, Degraded, or Progressing. For \ResourceGraphDefinition\, health is determined by conditions like \Ready\, \GraphRevisionsResolved\, and \KindReady\. For instances, it checks conditions such as \InstanceManaged\, \GraphResolved\, and \ResourcesReady\, while also considering the overall state (ACTIVE, IN\_PROGRESS, FAILED, ERROR). The implementation includes comprehensive test data covering various states (active, degraded, progressing, stale generation, missing status) to ensure accurate health reporting.

_resource\customizations/kro.run · high confidence

Add health checks for KServe InferenceService and LLMInferenceService

This change introduces bundled health-check scripts for KServe resources, enabling the UI to accurately reflect the status of InferenceService and LLMInferenceService instances. For InferenceService, the health logic evaluates the \modelStatus.transitionStatus\ and individual conditions, correctly reporting 'Suspended' when the \Stopped\ condition is True and 'Degraded' when conditions are False. For LLMInferenceService, the health check aggregates the top-level \Ready\ condition while surfacing details from dependent conditions (like \MainWorkloadReady\ or \WorkloadsReady\). It also handles 'Suspended' states when the \Stopped\ reason is present and prevents false 'Healthy' reports by checking for generation mismatches between the spec and the observed status.

_resource\customizations/serving.kserve.io · high confidence

Add health checks for Karpenter NodePool, NodeClaim, and EC2NodeClass

This change introduces resource-customization health scripts for three Karpenter Kubernetes resources: NodePool, NodeClaim, and EC2NodeClass. For NodePool and EC2NodeClass, health is determined by the Ready condition (Healthy/Degraded/Progressing). For NodeClaim, the health logic is more granular, checking for Disrupting status (Suspended), Ready condition, and intermediate phases like Launched, Registered, and Initialized to report Progressing states. Test data and test definitions are included to validate these health statuses.

_resource\customizations/karpenter.sh · high confidence

Add health checks for KnativeEventing and KnativeServing

Users can now see accurate health status for KnativeEventing and KnativeServing custom resources. This change introduces Lua-based health check scripts that evaluate the \status.conditions\ of these resources: KnativeEventing is considered healthy when both \InstallSucceeded\ and \Ready\ conditions are True, while KnativeServing requires \DependenciesInstalled\, \DeploymentsAvailable\, \InstallSucceeded\, and \Ready\ to all be True. Any other state (such as False, Unknown, or missing conditions) is reported as Progressing or Degraded, providing clearer visibility into the deployment state of these Knative components.

_resource\customizations/operator.knative.dev · high confidence

Add health checks for Kyverno policy types

Added health-check Lua scripts and test data for Kyverno policy resources (DeletingPolicy, GeneratingPolicy, ImageValidatingPolicy, MutatingPolicy, NamespacedDeletingPolicy, NamespacedGeneratingPolicy, NamespacedImageValidatingPolicy, NamespacedMutatingPolicy, NamespacedValidatingPolicy, and ValidatingPolicy). ArgoCD now reports these policies as Healthy, Degraded, or Progressing based on their conditionStatus.ready flag and underlying conditions (e.g., WebhookConfigured), with messages drawn from the first matching condition or the policy's status message.

_resource\customizations/policies.kyverno.io · high confidence

Add health checks for OLM Subscription resources

Users can now see the health status of OpenShift Operator Lifecycle Manager (OLM) Subscription resources in the UI. This change introduces a Lua-based health check script that evaluates the Subscription's status conditions and state (such as AtLatestKnown, UpgradePending, or UpgradeFailed) to report Healthy, Progressing, or Degraded states. It specifically handles manual approval scenarios, treating an InstallPlanPending condition as healthy if the operator is already installed, and correctly identifies degraded states for issues like failed install plans or unhealthy catalog sources.

_resource\customizations/operators.coreos.com · high confidence

Add health checks for OpenKruise workload types

Added health check scripts and corresponding test data for OpenKruise resource types (AdvancedCronJob, BroadcastJob, CloneSet, DaemonSet, StatefulSet, and Rollout). These scripts evaluate the status of these workloads to determine if they are Healthy, Progressing, Degraded, or Suspended, providing users with accurate visibility into the state of their OpenKruise-managed resources.

_resource\customizations/apps.kruise.io · high confidence

Add health checks for PostgreSQL and SolrCloud resources

Users now see accurate health status for acid.zalan.do PostgreSQL clusters and solr.apache.org SolrCloud resources in the UI. The new Lua scripts map the PostgresClusterStatus field to Healthy, Progressing, or Degraded states, and check Solr node readiness to report whether the cluster is fully ready.

_resource\_customizations/acid.zalan.do, resource\customizations/solr.apache.org · high confidence

Add health checks for Prometheus Operator Alertmanager, Prometheus, and ThanosRuler

Argo CD now displays accurate health statuses for Prometheus Operator custom resources (Alertmanager, Prometheus, and ThanosRuler). The new Lua-based health checks map the operator's 'Available' status condition to Argo CD states: 'Healthy' when all instances are available, 'Progressing' when pods are not yet ready, and 'Degraded' for other failure reasons. This provides clearer visibility into the operational state of these monitoring components within the Argo CD UI.

_resource\customizations/monitoring.coreos.com · high confidence

Add health checks for ServiceBinding and ServiceInstance

This change introduces health-check scripts for the \ServiceBinding\ and \ServiceInstance\ resources in the \services.cloud.sap.com\ API group. The scripts evaluate the resource's status conditions to report accurate health states: resources are marked as Healthy when ready, Degraded if creation or update conditions indicate failure, and Progressing while waiting for status updates, spec changes to be observed, or during deletion. This allows users to see the real-time operational state of their SAP Cloud Platform service bindings and instances directly in their tooling.

_resource\customizations/services.cloud.sap.com · high confidence

Add health checks for SpinApp resources

Users can now see the health status of SpinApp custom resources in the UI. A new Lua script evaluates the SpinApp's status conditions (Available, Progressing) and ready replica counts to report Healthy, Progressing, or Degraded states, with corresponding test data validating these scenarios.

_resource\customizations/core.spinkube.dev · high confidence

Add health checks for Tekton PipelineRun and TaskRun

Custom health-check scripts have been added for Tekton PipelineRun and TaskRun resources, enabling Argo CD to accurately reflect their lifecycle status. PipelineRuns and TaskRuns now report as Healthy when the 'Succeeded' condition is True, Degraded when it is False (indicating failure, timeout, or cancellation), and Progressing when the status is Unknown or not yet populated. Test data and validation files are included to verify these status mappings.

_resource\customizations/tekton.dev · high confidence

Add health checks for Velero Backup, Restore, and Schedule resources

Argo CD now displays accurate health statuses for Velero Backup, Restore, and Schedule custom resources. The new Lua-based health checks map Velero's internal phase states to Argo CD's Healthy, Degraded, and Progressing indicators, allowing users to visually track the success, failure, or ongoing status of their backup and restore operations directly in the UI.

_resource\customizations/velero.io · high confidence

Add health checks for VolumeSnapshot and VolumeSnapshotContent resources

Users can now see the health status of Kubernetes VolumeSnapshot and VolumeSnapshotContent resources. The system evaluates the \readyToUse\ and \error\ fields in the resource status to display 'Healthy' (Ready to use), 'Degraded' (with the specific error message), or 'Progressing' (Waiting for status), providing clearer visibility into the state of snapshot operations.

_resource\customizations/snapshot.storage.k8s.io · high confidence

Add health checks for cert-manager ACME Order and Challenge resources

Argo CD now displays accurate health statuses for cert-manager ACME Order and Challenge custom resources. The new Lua-based health checks map the ACME state to Argo CD's Healthy, Degraded, or Progressing indicators, allowing users to see whether certificate orders and challenges are valid, pending, or errored directly in the application UI.

_resource\customizations/acme.cert-manager.io · high confidence

Add health checks for cert-manager Certificate and Issuer resources

Users can now see the operational status of cert-manager Certificate and Issuer custom resources in the Argo CD UI. This change introduces Lua-based health scripts for both resource types that inspect the \status.conditions\ field: resources with a \Ready\ condition set to \True\ are marked as Healthy, those with \Ready\ set to \False\ are marked as Degraded (displaying the error message), and resources lacking a status or ready condition are shown as Progressing. This provides immediate visibility into certificate issuance and issuer registration states directly within the application view.

_resource\customizations/certmanager.k8s.io · high confidence

Add health checks for external-secrets.io Cluster resources

Users can now see accurate health status for ClusterExternalSecret and ClusterSecretStore resources in the UI. The new health scripts evaluate the latest status conditions: ClusterExternalSecret is marked Healthy when the last condition is Ready, and Degraded for PartiallyReady or NotReady states; ClusterSecretStore is marked Healthy or Degraded based on whether the Ready condition is True or False, otherwise showing Progressing.

_resource\_customizations/external-secrets.io/ClusterExternalSecret, resource\customizations/external-secrets.io/ClusterSecretStore · high confidence

Add health checks for kubernetes-client.io ExternalSecret resources

Users can now see the operational status of ExternalSecret resources from the kubernetes-client.io API group. A new Lua health script evaluates the resource's status field, reporting 'Healthy' when the secret is successfully fetched, 'Degraded' if an error occurs (displaying the specific error message), and 'Progressing' while waiting for the secret to be retrieved.

_resource\customizations/kubernetes-client.io · high confidence

Add health checks for nmstate NodeNetworkConfigurationPolicy

Users managing nmstate NodeNetworkConfigurationPolicy resources will now see accurate health status indicators in the UI. The new Lua health script maps the resource's status conditions to ArgoCD health states: Available=True becomes Healthy, Degraded=True becomes Degraded, Progressing=True becomes Progressing, and Ignored=True becomes Suspended. If no status is present, the resource is marked as Progressing.

_resource\customizations/nmstate.io · high confidence

Add health status checks for AWS ACK resources

Users can now see accurate health statuses for AWS resources managed by the AWS Controllers for Kubernetes (ACK). This change introduces a health check script that evaluates ACK-specific status conditions, reporting resources as Healthy when the Ready condition is True, Progressing when it is False or absent, and Degraded if a terminal ACK.Terminal condition is present.

_resource\customizations/\.services.k8s.aws · high confidence_

Add health status checks for Camel K Integration resources

Users can now see the health status of Camel K Integration resources in the dashboard. A new health check script evaluates the Integration's status conditions, reporting 'Healthy' when the Ready condition is True, 'Degraded' when it is False, and 'Progressing' while the integration is being built or deployed.

_resource\customizations/camel.apache.org · high confidence

Add health status checks for Kyverno ClusterPolicy and Policy resources

Users can now see accurate health statuses for Kyverno ClusterPolicy and Policy resources in the Argo CD UI. The system maps the Kyverno 'Ready' condition to Argo CD health states: a 'Ready=True' condition marks the resource as Healthy, 'Ready=False' marks it as Degraded, and the absence of a status or an incomplete condition shows as Progressing. This provides clearer visibility into whether Kyverno policies are fully loaded, active, or encountering errors.

_resource\customizations/kyverno.io · high confidence

Add health status checks for MonoVertexRollout resources

Users can now see the health status of MonoVertexRollout resources in the UI. A new health check script evaluates the resource's status conditions and phase to report whether the rollout is Healthy, Progressing, Degraded, or Paused, providing specific reasons for each state.

_resource\customizations/numaplane.numaproj.io/MonoVertexRollout · high confidence

Add health status customization for Logstash resources

Users can now see the health status of Logstash resources in the UI, mapped from the \status.health\ field. A status of 'green' is displayed as Healthy, 'yellow' as Progressing, and 'red' as Degraded; any other state or missing status is shown as Progressing with the message 'Waiting for Logstash'.

_resource\customizations/logstash.k8s.elastic.co · high confidence

Add health status customization for Route53 ResourceRecordSet

Users now receive accurate health status indicators for AWS Route53 ResourceRecordSet resources managed via Crossplane. A new Lua health script evaluates the resource's Ready and Synced conditions to report states such as Healthy, Progressing, Suspended, or Degraded, providing clear visibility into the reconciliation state of DNS record sets.

_resource\customizations/route53.aws.crossplane.io · high confidence

Add health status for cert-manager CertificateRequest resources

Argo CD now displays specific health statuses for cert-manager CertificateRequest custom resources. The new health check maps the resource's internal conditions to Argo CD states: 'Healthy' when the certificate is issued, 'Progressing' while pending, and 'Degraded' if the request is denied, invalid, or has failed.

_resource\customizations/cert-manager.io/CertificateRequest · high confidence

Add health status for cert-manager trust-manager Bundle resources

Argo CD now displays accurate health status for cert-manager trust-manager Bundle custom resources. The new health check maps the Bundle's 'Synced' status condition to Argo CD states: 'Healthy' when synced to all target namespaces, 'Degraded' if the source ConfigMap or Secret is missing, and 'Progressing' while the status is not yet populated.

_resource\customizations/trust.cert-manager.io · high confidence

Add health status reporting for Argo CD Image Updater resources

Argo CD now displays the health status of ImageUpdater custom resources, allowing users to see whether the updater is Healthy, Progressing, or Degraded. The new health check logic evaluates the ImageUpdater's status conditions—prioritizing Error, Reconciling, and Ready states—to provide clear feedback on reconciliation progress and any issues, such as image pull failures or missing registry credentials.

_resource\customizations/argocd-image-updater.argoproj.io · high confidence

Add health status reporting for DatadogMetric resources

Users can now see the health status of DatadogMetric custom resources in their cluster. A new health check script evaluates the resource's status conditions, marking the metric as 'Degraded' if an Error condition is present or if the Valid condition is False, and 'Healthy' otherwise. This provides immediate visibility into whether a DatadogMetric is functioning correctly or encountering issues such as invalid queries or API fetch failures.

_resource\customizations/datadoghq.com · high confidence

Add health status reporting for Gardener Shoot resources

Users can now see the health status of Gardener Shoot resources in the UI, determined by the \shoot.gardener.cloud/status\ label. The system maps this label to specific health states: 'healthy' shows as Healthy, 'progressing' as Progressing, 'unhealthy' as Degraded, and 'unknown' as Unknown. This change provides clearer visibility into the operational state of managed Kubernetes clusters.

_resource\customizations/core.gardener.cloud · high confidence

Add health status reporting for GrafanaOrg resources

Users can now see the health status of GrafanaOrg resources in the UI. This change introduces a health check script that evaluates the \Ready\ condition in the resource's status, reporting 'Healthy' when reconciled, 'Degraded' if the condition is false, and 'Progressing' otherwise.

_resource\customizations/grafana-org-operator.kubitus-project.gitlab.io · high confidence

Add health status reporting for OnePasswordItem resources

Users can now see the health status of OnePasswordItem resources in their UI. A new Lua health check script evaluates the resource's status conditions, reporting 'Healthy' when the Ready condition is True, 'Degraded' when it is False, and 'Progressing' otherwise. This allows for better visibility into the state of OnePassword integrations.

_resource\customizations/onepassword.com · high confidence

Add health status reporting for OpenFaaS Functions

A new health-check script for the OpenFaaS Function resource has been added, enabling the platform to report the operational state of Functions directly in the UI and CLI. The script evaluates the Function's status conditions to determine if it is Healthy (Ready=True with available replicas), Degraded (Ready=False or Stalled=True), Suspended (Ready=True but zero replicas), or Progressing (default state). Test data and validation scripts are included to verify these states against sample Function resources.

_resource\customizations/openfaas.com · high confidence

Add health status reporting for RDS DBCluster and DBInstance resources

Users can now see the health status of AWS RDS DBCluster and DBInstance resources managed via Crossplane. This change introduces Lua-based health check scripts that evaluate the resource's Ready and Synced conditions to report statuses such as Healthy, Progressing, Degraded, or Suspended, providing clearer visibility into the operational state of these database resources.

_resource\customizations/rds.aws.crossplane.io · high confidence

Add health-check customization for OCS StorageCluster resources

Users managing OpenShift Container Storage (OCS) clusters now see accurate health status in the UI. A new Lua script evaluates the \StorageCluster\ resource's status conditions, reporting 'Degraded' when a Degraded condition is True, 'Progressing' when a Progressing condition is True, and 'Healthy' when an Available condition is True. This customization ensures that the lifecycle state of OCS storage clusters is correctly reflected alongside other managed resources.

_resource\customizations/ocs.openshift.io · high confidence

Add health-check customizations for Kruise GameServer and GameServerSet

Users can now see accurate health status for Kruise \GameServer\ and \GameServerSet\ resources in the dashboard. The new Lua-based health checks evaluate \GameServer\ readiness by comparing current and desired states and checking pod conditions, reporting Healthy, Progressing, Degraded, or Unknown. For \GameServerSet\, the check monitors rolling update progress, identifying when all replicas are updated and ready, when the update is paused or partitioned (Suspended), or when it is still progressing.

_resource\customizations/game.kruise.io · high confidence

Add health-check customizations for RabbitMQ resources

Health-check logic is now defined for RabbitMQ resources (Binding, Exchange, Permission, Policy, Queue, Shovel, User, Vhost, and RabbitmqCluster). For the child resources, the health status is determined by the Ready condition: SuccessfulCreateOrUpdate maps to Healthy, FailedCreateOrUpdate to Degraded, and missing/unknown conditions to Unknown. For RabbitmqCluster, health is derived from ReconcileSuccess, ClusterAvailable, and AllReplicasReady conditions, with Unknown conditions treated as Progressing to avoid false Degraded states during cluster formation, and a specific case for ScaledToZero reporting Suspended status.

_resource\customizations/rabbitmq.com · high confidence

Add health-check support for Percona XtraDB Cluster

Argo CD now displays accurate health status for Percona XtraDB Cluster resources. A new Lua health script evaluates the cluster's \status.state\ to report specific conditions: 'Healthy' when ready, 'Progressing' during initialization, 'Degraded' when stopping or in error, and 'Unknown' when paused or in an unrecognized state. This change ensures that users can visually track the lifecycle and operational health of their database clusters directly within the Argo CD UI.

_resource\customizations/pxc.percona.com · high confidence

Add health-checks for ECK Elastic Beat resources

Argo CD now displays the health status of Elastic Cloud on Kubernetes (ECK) Beat resources by evaluating the \status.health\ field. Users will see Healthy, Degraded, or Progressing states based on whether the Beat reports a green, red, or yellow health status, providing clearer visibility into the deployment state of Beats within the Argo CD UI.

_resource\customizations/beat.k8s.elastic.co · high confidence

Add health-checks for Elasticsearch

This change introduces a Lua-based health-check script for the Elasticsearch Kubernetes resource, enabling Argo CD to accurately reflect the cluster's operational status. The script evaluates the \status.availableNodes\ count against the desired node set configuration to detect provisioning progress, and maps the Elasticsearch \status.health\ (green, yellow, red) and \status.phase\ (Ready, ApplyingChanges, MigratingData, Invalid) fields to Argo CD health states (Healthy, Progressing, Degraded). This allows users to see real-time health indicators for their Elasticsearch deployments directly in the Argo CD UI.

_resource\customizations/elasticsearch.k8s.elastic.co · high confidence

Add manual rolling-update action for StrimziPodSet resources

Users can now manually trigger a rolling update for StrimziPodSet resources by setting the \strimzi.io/manual-rolling-update\ annotation to \true\. This new action is automatically discovered when the annotation is present and becomes disabled once the rolling update has been initiated, preventing duplicate restarts.

_resource\customizations/core.strimzi.io · high confidence

Add pause, unpause, and data-loss control actions for PipelineRollout

Users can now directly pause, unpause (gradually or fast), and control data-loss permissions for Numaplane PipelineRollout resources via new UI actions. The pause action sets the pipeline lifecycle to Paused, while unpause-gradual and unpause-fast resume the pipeline with the corresponding fastResume strategy flag. Additionally, allow-data-loss and disallow-data-loss actions toggle the numaplane.numaproj.io/allow-data-loss annotation to manage data-loss behavior during rollouts. These actions are dynamically enabled or disabled based on the rollout's current state and configuration.

_resource\customizations/numaplane.numaproj.io/PipelineRollout/actions · high confidence

Add restart and scale actions for StatefulSets

Users can now trigger restart and scale actions directly on StatefulSet resources. The restart action injects a \kubectl.kubernetes.io/restartedAt\ annotation to the pod template, signaling Kubernetes to perform a rolling restart. The scale action allows users to specify a target replica count, which updates the StatefulSet's \spec.replicas\ field. These actions are defined via Lua scripts in the resource customizations and include validation to ensure the replica count is a valid number.

_resource\customizations/apps/StatefulSet · high confidence

Add static UI badge and embed RBAC policy assets

The assets package now includes a new SVG badge image (badge.svg) for displaying application status, and embeds the built-in RBAC policy definitions (builtin-policy.csv) and Casbin model configuration (model.conf) directly into the binary via Go's embed package. This ensures the default read-only/admin roles and the status badge graphic are available without external file dependencies.

assets · high confidence

Add toggle-auto-sync action for Argo CD Applications

Users can now toggle the auto-sync state of an Argo CD Application directly from the UI via a new 'toggle-auto-sync' resource action. This action dynamically displays as either 'Enable Auto-Sync' or 'Disable Auto-Sync' depending on the current state. When triggered, it sets the \spec.syncPolicy.automated.enabled\ field to the opposite boolean value while preserving existing \prune\ and \selfHeal\ configurations, allowing for quick on/off control of automated synchronization without manual YAML editing.

_resource\customizations/argoproj.io/Application · high confidence

Added Argo CD v3 resource generation tool

A new command-line tool has been added to the hack/gen-resources/cmd directory to generate Argo CD resources. The tool initializes a command structure and includes a GCP authentication plugin to support authentication against GKE clusters.

hack/gen-resources/cmd · high confidence

Added GPG public key management API client

The API client now includes generated code for the GPG public key service, enabling users to query, create, and delete GnuPG public keys via the API. This adds the necessary client-side stubs and gRPC-gateway reverse proxy handlers to support the new GPG key management capabilities.

pkg/apiclient/gpgkey · high confidence

Added Notification Service API client stubs

New Go client code has been added for the Notification Service, enabling programmatic interaction with notification resources. This includes generated protobuf definitions for Trigger and Service entities, as well as gRPC-Gateway handlers that expose RESTful JSON endpoints for listing triggers, services, and templates.

pkg/apiclient/notification · high confidence

Added empty API rules violation exceptions list

An empty \violation\_exceptions.list\ file has been added to the \pkg/apis/api-rules\ directory. This file serves as the baseline for defining exceptions to API rules, currently containing no specific exceptions.

pkg/apis/api-rules · high confidence

Added health checks for Humio custom resources

Health check scripts and corresponding test data have been added for HumioAction, HumioAlert, HumioCluster, HumioIngestToken, HumioParser, HumioRepository, and HumioView resources. These scripts evaluate the \status.state\ field of each resource to report its health status as Healthy, Missing, Degraded, Unknown, or Progressing, allowing users to quickly identify the operational state of their Humio components.

_resource\customizations/core.humio.com · high confidence

Added health checks for IstioOperator, Jaeger, and ZookeeperCluster resources

Users can now see accurate health status for IstioOperator, Jaeger, and ZookeeperCluster custom resources. The system evaluates IstioOperator status codes (e.g., HEALTHY, ERROR, UPDATING) to report Healthy, Degraded, or Progressing states. Jaeger resources are marked Healthy when their phase is Running, Degraded if Failed, and Progressing otherwise. ZookeeperCluster resources are considered Healthy only when all replicas are ready, ensuring users can track the readiness of these specific components during deployment and updates.

_resource\_customizations/install.istio.io, resource\_customizations/jaegertracing.io, resource\customizations/zookeeper.pravega.io · high confidence

Added health status checks for Keptn Analysis and KeptnMetric resources

Users will now see accurate health statuses for Keptn Analysis and KeptnMetric custom resources in the UI. The Analysis resource displays 'Healthy' when the analysis passes or has warnings, 'Degraded' if it fails, and 'Progressing' while running. The KeptnMetric resource shows 'Healthy' when a metric value is successfully retrieved (even if an error message field is empty), 'Degraded' if a non-empty error message is present, and 'Progressing' when no value or error is yet available.

_resource\customizations/metrics.keptn.sh · high confidence

Added local Kubernetes test environment launcher

A new Go utility at hack/k8s/main.go has been introduced to start a local Kubernetes test environment using controller-runtime's envtest. This tool initializes the cluster, writes the kubeconfig, waits for the API server to become available, and applies the base configuration manifests, facilitating local development and testing workflows.

hack/k8s · high confidence

Added migration helper scripts for gitops-engine integration

New shell scripts have been added to the hack/migrate-gitops-engine directory to assist with integrating the gitops-engine repository. The merge.sh script automates fetching and merging a specific branch from a user's fork, followed by post-merge updates. The replace-vendor.sh script handles the transition from 'go mod vendor' to 'go work vendor' by updating build files and syncing Go modules. The update-dockerfile.sh script modifies the Dockerfile to correctly copy Go module files into the gitops-engine subdirectory.

hack/migrate-gitops-engine · high confidence

AnsibleJob health status reporting

The Argo CD UI now displays accurate health status for AnsibleJob resources (tower.ansible.com) by mapping the job's lifecycle state to standard health indicators: successful jobs are marked Healthy, while failed, error, or canceled jobs are marked Degraded. Jobs that are new, pending, waiting, or running are shown as Progressing, and resources without status information are also treated as Progressing.

_resource\customizations/tower.ansible.com · high confidence

Application controller command structure refactored and new configuration flags added

The application controller command entry point has been restructured into a new file, introducing several new configuration options for users. A new \--hydration-processors\ flag allows configuring the concurrency of the manifest hydration queue (defaulting to 5). Metrics exposure is enhanced with new flags (\--metrics-application-labels\, \--metrics-application-conditions\, \--metrics-cluster-labels\) that can be configured via environment variables to include specific labels and conditions in Prometheus metrics. Additionally, the command now supports \--app-hard-resync\ for hard resync periods, \--server-side-diff\ to enable server-side diffing, and \--enable-k8s-event\ to control Kubernetes event logging. The command also integrates with the commit server and supports configurable sharding algorithms and dynamic cluster distribution.

cmd/argocd-application-controller · high confidence

Application controller implementation and test suite for Argo CD v3

The application controller logic and its associated test suite have been introduced in the v3 codebase, establishing the core reconciliation, refresh, and operation handling mechanisms for managing Argo CD applications. This change includes the primary controller implementation, benchmark tests for performance validation, and comprehensive unit tests for informer event handling and application processing logic.

controller · high confidence

ApplicationSet API client support for namespace-scoped queries and watch events

The ApplicationSet API client now supports querying and watching ApplicationSets in specific namespaces via the new \AppsetNamespace\ field in \ApplicationSetGetQuery\, \ApplicationSetListQuery\, and \ApplicationSetWatchQuery\. Additionally, the client introduces a \Watch\ method that streams \ApplicationSetWatchEvent\ messages, with a custom forwarder configured to extract the ApplicationSet name from these events for efficient stream handling.

pkg/apiclient/applicationset · high confidence

ApplicationSet controller introduces configurable concurrency and performance tuning flags

The ApplicationSet controller now exposes new command-line flags to allow administrators to tune performance and concurrency. Users can configure the maximum number of concurrent reconciliations via \--max-concurrent-reconciliations\, control the rate of application updates with \--concurrent-application-updates\ (defaulting to 1), and adjust the cache synchronization period using \--cache-sync-period\. Additionally, the controller now supports exposing pprof endpoints for profiling and includes metrics for GitHub API rate limits, providing better observability and control over resource usage.

cmd/argocd-applicationset-controller · high confidence

ApplicationSet health status reporting

Added a Lua-based health check for the ApplicationSet resource that maps its internal status conditions to Argo CD health states. Users will now see ApplicationSets reported as Degraded when ErrorOccurred or ResourcesUpToDate conditions indicate issues, Progressing when a RolloutProgressing condition is active or status is pending, and Healthy when ResourcesUpToDate is true.

_resource\customizations/argoproj.io/ApplicationSet · high confidence

ApplicationSet now supports template patches to override generated applications

Users can now define a \templatePatch\ in their ApplicationSet spec to apply strategic merge patches to the applications generated from the template. This new capability allows for fine-grained overrides of specific fields (such as annotations, source configurations, or sync policies) on a per-application basis without modifying the base template. The implementation includes a new \patch.go\ module that handles the patching logic and explicitly protects the \project\ field from being overwritten by patches to maintain security boundaries, along with comprehensive tests for both JSON and YAML patch formats.

applicationset/controllers/template · high confidence

ApplicationSet services refactor and GitHub API metrics

The ApplicationSet controller now exposes detailed Prometheus metrics for GitHub API interactions, including request counts, durations, and rate-limit status (remaining, limit, reset, used), allowing operators to monitor API usage and throttling. Additionally, the service layer has been refactored to centralize repository access through a new \Repos\ interface (\repo\_service.go\), which delegates Git and OCI file/directory retrieval to the repo server and supports source integrity verification. A utility function for Bitbucket client setup now clones the default HTTP transport to prevent idle connection buildup issues.

applicationset/services · high confidence

ApplicationSet status now tracks individual application resource health and sync status

The ApplicationSet controller now maintains a detailed status map for each generated application, recording its sync status, health status, and group/version/kind metadata. This allows users to observe the specific state of each child application directly within the ApplicationSet's status, and ensures that status entries are automatically cleaned up when an application is deleted.

applicationset/status · high confidence

Argo CD API server adds mTLS, source IP logging, and Swagger UI control flags

The Argo CD API server command now exposes new configuration options for enhanced security and observability. Users can enable mutual TLS (mTLS) for communication with the repository server using the new \--repo-server-ca-cert-path\, \--repo-server-client-cert-path\, and \--repo-server-client-cert-key-path\ flags, which default to auto-mounted secret paths. Additionally, a new \--enable-source-ip-logging\ flag allows administrators to opt-in to logging the client's source IP in API request logs, and a \--disable-swagger-ui\ flag provides the ability to hide the Swagger UI endpoint entirely.

cmd/argocd-server · high confidence

Argo CD Commit Server introduces GPG signing for hydrated commits

The new Argo CD Commit Server component now supports signing hydrated commits using GPG. Administrators can enable this feature by providing a signing key path via the \--signing-key-path\ flag; an optional passphrase file can be specified with \--signing-key-passphrase-file\. The server validates that a passphrase is not provided without a key, initializes a shared GnuPG home, imports the key, and presets the passphrase into the gpg-agent to allow non-interactive signing. This capability is currently in Alpha.

cmd/argocd-commit-server · high confidence

Argo CD now reports health status for ArgoEvents EventBus resources

Users can now see the health status of ArgoEvents EventBus custom resources in the Argo CD UI. A new Lua health-check script evaluates the EventBus's 'Deployed' condition, displaying 'Healthy' when deployment succeeds and 'Degraded' with specific error messages (such as unsupported JetStream versions) when it fails, providing clearer visibility into the operational state of event bus infrastructure.

_resource\customizations/argoproj.io/EventBus · high confidence

Argo CronWorkflow and WorkflowTemplate resource customizations

Added resource customizations for Argo CronWorkflow and WorkflowTemplate resources. For CronWorkflow, a health check script now reports 'Healthy' by default and when the 'Completed' condition is true, while marking the resource 'Degraded' if 'SpecError' or 'SubmissionError' conditions are present. A 'Create Workflow' action allows users to manually instantiate a Workflow from a CronWorkflow, preserving labels, annotations, and finalizers from the spec's workflowMetadata. For WorkflowTemplate, a 'Create Workflow' action enables instantiating a Workflow from a template, setting the appropriate owner references and labels. Test cases are included for both the health logic and the action outputs.

_resource\customizations/argoproj.io/CronWorkflow · high confidence

Argo Rollout custom actions now support pause, resume, abort, retry, promote-full, and skip-current-step

This change introduces a comprehensive set of custom actions for Argo Rollouts, allowing users to directly control rollout lifecycle from the UI. The new actions include pausing and resuming rollouts, aborting a rollout, retrying an aborted one, promoting a canary rollout fully, and skipping the current canary step. The Lua-based discovery logic in this location determines which actions are available based on the Rollout's current state (e.g., paused, aborted, fully promoted) and version (supporting both v0.9 and v0.10+ behaviors for actions like promote-full).

_resource\customizations/argoproj.io/Rollout/actions · high confidence

ArgoCD ConfigManagementPlugin server adds OpenTelemetry tracing and configurable logging

The ConfigManagementPlugin (CMP) server now supports OpenTelemetry gRPC tracing, allowing users to configure the OTLP endpoint address, insecure mode, custom headers, extra attributes, and a configurable sampling ratio via new command-line flags and environment variables. Additionally, the server's default logging format has been switched to JSON, and users can now explicitly set the log level and format at startup.

cmd/argocd-cmp-server · high confidence

Automated CRD generation tool for Argo CD resources

A new Go-based utility at hack/gen-crd-spec has been introduced to automate the generation of Custom Resource Definition (CRD) YAML files for Argo CD's core resources (Application, AppProject, and ApplicationSet). This tool leverages controller-gen to extract CRD schemas from the Go API definitions, then post-processes the output to remove problematic validation fields (such as creationTimestamp and status) and strip descriptions where necessary, ensuring the final manifests are clean and compatible with Kubernetes v1 API standards before writing them to the manifests/crds directory.

hack/gen-crd-spec · high confidence

Automated checksum generation scripts for build tools

Added shell scripts to automatically download and generate SHA256 checksum files for Helm, Kustomize, git-lfs, protoc, and oras binaries. These scripts streamline the process of updating tool versions in the local development environment by fetching official release checksums and storing them in the expected directory structure, reducing manual effort and potential errors when upgrading dependencies.

hack/installers/checksums · high confidence

Automated generation of Argo CD notification service documentation

A new script in the \hack/gen-docs\ directory now automatically generates documentation for Argo CD notification services. This tool copies service-specific documentation files into the \docs/operator-manual/notifications/services\ directory and updates the \mkdocs.yml\ navigation structure to include these new pages, ensuring the documentation remains synchronized with the available notification services.

hack/gen-docs · high confidence

Automated previous release detection for release notes

A new Go-based utility in the \hack/get-previous-release\ directory now automatically determines the correct previous release version for generating release notes. The tool analyzes git tags to identify the most recent valid prior version, applying specific rules such as falling back to the previous minor series for new minor releases (e.g., v2.13.0 looks to v2.12.x) and handling release candidates correctly. This ensures that release notes are accurately attributed to the correct preceding version, and the workflow will now fail if a previous version cannot be determined.

hack/get-previous-release · high confidence

Cluster API supports identifying clusters by name

The cluster API now allows clients to locate clusters using a human-readable name in addition to the traditional API server URL. This is implemented via a new \ClusterID\ message type and updated \ClusterQuery\ structure in the generated protobuf definitions, enabling more flexible cluster selection in API calls.

pkg/apiclient/cluster · high confidence

Config management plugin server introduces gRPC observability and keep-alive configuration

The cmpserver now exposes OpenTelemetry tracing via a gRPC stats handler and Prometheus metrics through middleware interceptors, providing better visibility into plugin server performance. Additionally, the server configures gRPC keep-alive enforcement policies and registers health and reflection services, enhancing operational reliability and monitoring capabilities for the config management plugin infrastructure.

cmpserver · high confidence

CronJob and Job resource customizations for Argo CD

This change introduces resource customizations for Kubernetes CronJob and Job resources in the Argo CD UI. For CronJobs, it adds a 'Create Job' action to manually instantiate a Job from a CronJob, along with 'Suspend' and 'Resume' actions. It also defines health status logic for CronJobs, treating suspended jobs as Healthy and handling various execution states (active, degraded, never scheduled). For Jobs, it adds 'Suspend', 'Resume', and 'Terminate' actions, allowing users to manage job lifecycle directly from the UI. The 'Terminate' action for Jobs adds a 'FailureTarget' condition to mark the job as explicitly terminated.

_resource\customizations/batch · high confidence

Custom health and action support for Flux source resources

Argo CD now provides built-in health assessment and manual action capabilities for Flux source resources (Bucket, GitRepository, HelmChart, HelmRepository, and OCIRepository). The health checks accurately reflect the resource's state, including a new 'Suspended' status when the spec.suspend field is true, and correctly identify Healthy, Progressing, or Degraded states based on status conditions. Additionally, users can now trigger 'reconcile', 'suspend', and 'resume' actions directly from the UI for these resources, with the UI intelligently enabling or disabling these actions based on the current suspension state.

_resource\customizations/source.toolkit.fluxcd.io · high confidence

Custom health checks and lifecycle actions for Numaflow resources

Added resource customizations for Numaflow InterStepBufferService and MonoVertex resources, including Lua-based health checks that accurately report Progressing, Healthy, Degraded, and Paused states (including detection of failed progressive upgrades). Also introduced custom UI actions for MonoVertex to pause, unpause (gradually or fast), and force-promote, with discovery logic that disables pause/unpause on child resources managed by rollouts to prevent self-healing conflicts.

_resource\customizations/numaflow.numaproj.io · high confidence

Define API group and resource constants for Application, AppProject, and ApplicationSet

The application API package now registers the core constants for the Argo CD resource types, including Application, AppProject, and ApplicationSet. This establishes the API group (argoproj.io) and defines the kind, singular, plural, and short names for these resources, enabling the system to correctly identify and interact with these custom resources.

pkg/apis/application · high confidence

Generated API client for Argo CD Settings service

This change introduces the generated Go code for the Argo CD Settings service API, including the protobuf definitions and the gRPC-gateway reverse proxy handlers. For users, this establishes the programmatic interface for retrieving server settings, such as OIDC and Dex configurations, UI banner options, and plugin lists, enabling external tools and clients to query and interact with the Argo CD configuration via RESTful JSON APIs.

pkg/apiclient/settings · high confidence

Generated API client stubs for the Certificate Service

Added the generated Go code (\certificate.pb.go\ and \certificate.pb.gw.go\) for the Certificate Service API, which exposes gRPC and REST endpoints for managing repository certificates. This includes the \RepositoryCertificateQuery\ message for filtering certificates by host name pattern, type, and sub-type, as well as the \RepositoryCertificateCreateRequest\ supporting batch creation with an upsert option. The generated gateway code registers HTTP handlers for listing, creating, and deleting certificates, enabling external tools and UI components to interact with certificate resources via standard RESTful JSON APIs.

pkg/apiclient/certificate · high confidence

Generated v3 clientset, informers, and listers for Application, ApplicationSet, and AppProject

The \pkg/client\ package now includes automatically generated Go code for interacting with Argo CD's core resources. This adds a typed clientset for the \argoproj.io/v1alpha1\ API group, providing structured clients for Applications, ApplicationSets, and AppProjects, along with corresponding shared informers and listers to support efficient Kubernetes resource watching and caching.

pkg/client · high confidence

Health checks added for AWS IAM and S3 Crossplane resources

Added health-check scripts and corresponding test data for AWS Crossplane resources, specifically \iam.aws.crossplane.io\ (Policy, Role, RolePolicyAttachment) and \s3.aws.crossplane.io\ (Bucket). These scripts evaluate the \Ready\ and \Synced\ status conditions to report resource health as Healthy, Progressing, Suspended, or Degraded, allowing users to see the operational state of their IAM policies, roles, attachments, and S3 buckets directly in the UI.

_resource\_customizations/iam.aws.crossplane.io, resource\customizations/s3.aws.crossplane.io · high confidence

Health checks added for Envoy Gateway Extension CRDs

The system now reports health status for Envoy Gateway Extension Custom Resource Definitions (Backend, BackendTrafficPolicy, ClientTrafficPolicy, EnvoyExtensionPolicy, EnvoyPatchPolicy, and SecurityPolicy). These new health check scripts evaluate the 'Accepted' condition in the resource status to display Healthy, Degraded, or Progressing states, ensuring that stale or unaccepted configurations are correctly identified.

_resource\customizations/gateway.envoyproxy.io · high confidence

Health status checks for MedusaBackupJob and MedusaTask

Added health-check scripts for the MedusaBackupJob and MedusaTask custom resources, enabling the platform to report their operational state as Healthy, Degraded, Progressing, or Unknown. The Lua logic evaluates the \status.finished\ and \status.failed\ fields to determine success or failure, checks for missing status data, and flags a Progressing state when the \observedGeneration\ does not match the resource generation, ensuring users can accurately track the completion and health of Medusa backup and task operations.

_resource\customizations/medusa.k8ssandra.io · high confidence

Health status checks for Microgateway policies

The resource customization for \microgateway.airlock.com\ now includes a Lua-based health check script that evaluates the status of gateway policies. This script inspects the \status.ancestors\ and \conditions\ fields of policy resources (such as AccessControlPolicy, ContentSecurityPolicy, and RateLimitPolicy) to determine if they are Healthy, Degraded, or Progressing. It specifically checks for Accepted and ResolvedRefs conditions, handles observed generation mismatches, and provides detailed messages for conflicts or missing references, allowing users to accurately monitor the operational state of their microgateway policies.

_resource\customizations/microgateway.airlock.com · high confidence

Health status for CloudFront Distributions

Added a health-check script for the \cloudfront.aws.crossplane.io/v1alpha1\ Distribution resource that maps the underlying Kubernetes conditions to user-friendly health statuses. The script reports 'Healthy' when both Ready and Synced conditions are true, 'Suspended' when the resource is paused, 'Degraded' on reconciliation errors, and 'Progressing' while the distribution is being created or is unavailable. Comprehensive test cases are included to verify these mappings across various state transitions.

_resource\customizations/cloudfront.aws.crossplane.io · high confidence

Health-check support for Contour HTTPProxy and ExtensionService resources

Users can now see accurate health statuses for Project Contour's HTTPProxy and ExtensionService custom resources. The system evaluates the 'Valid' status condition to report Healthy or Degraded states, while correctly handling edge cases such as stale status updates (via generation matching), missing status data, and parent-child inclusion cycles that would otherwise block deployments.

_resource\customizations/projectcontour.io · high confidence

Introduce Argo CD v3 resource generation CLI

The \hack/gen-resources\ tool is updated to target Argo CD v3, introducing a new CLI entry point (\argocd-generator\) with \generate\ and \clean\ subcommands. This allows users to programmatically create or remove Argo CD resources—including projects, repositories, clusters, and applications—by providing a configuration file, streamlining the setup of v3-compatible environments.

hack/gen-resources/cmd/commands · high confidence

Introduce Config Management Plugin (CMP) server service

This change introduces the cmpserver/plugin package, which implements the ConfigManagementPluginService gRPC interface. It provides the core logic for discovering, validating, and executing external configuration management plugins to generate Kubernetes manifests. The implementation includes plugin configuration parsing (config.go), the main service logic for running plugin commands with proper process lifecycle management and OpenTelemetry tracing (plugin.go), and the corresponding protobuf definitions (plugin.proto). It also adds platform-specific process handling for Unix and Windows environments (plugin\_unix.go, plugin\_windows.go) and comprehensive unit tests (config\_test.go, plugin\_test.go) along with test fixtures for kustomize and ksonnet plugins.

cmpserver/plugin · high confidence

Introduce Plugin Generator service for ApplicationSet

Adds a new plugin service within the ApplicationSet system that enables external plugins to generate parameters for ApplicationSets. The implementation includes a Go service (\plugin\_service.go\) that communicates with an external HTTP endpoint to retrieve parameter sets, along with utility functions to parse secret keys for authentication and corresponding unit tests to verify the service's behavior.

applicationset/services/plugin · high confidence

Introduce Source Hydrator controller for manifest generation

This change introduces the new Source Hydrator component in the controller package, which automates the generation and commit of Kubernetes manifests from dry source definitions. The hydrator manages a deduped work queue to process applications sharing the same source and destination repositories, handling status updates, retry logic, and integration with the commit server and repo-server to persist hydrated manifests. It includes configurable commit metadata (author name/email, message templates), support for separate destination repositories, and parallelized repo-server calls to improve performance.

controller/hydrator · high confidence

Introduce argocd-dex CLI with configurable logging and TLS options

The new \argocd-dex\ command-line interface provides tools to manage the Dex authentication server. It includes a \rundex\ subcommand that runs the Dex server, automatically generating configuration from Argo CD settings and restarting the process when settings change. Users can now control the logging format (defaulting to JSON) and log level via \--logformat\ and \--loglevel\ flags, and can disable TLS on the HTTP endpoint using the \--disable-tls\ flag. A \gendexcfg\ subcommand is also available to generate and output the Dex configuration YAML for inspection.

cmd/argocd-dex · high confidence

Introduce centralized Renovate configuration presets

This change introduces a new \renovate-presets\ directory containing reusable configuration presets for Renovate, allowing repositories to reference shared rules via the \extends\ field. The presets define default behaviors for dependency management, including security vulnerability alerts, labeling strategies for JavaScript, Go, and Python updates, and custom managers for tracking versions in shell scripts, YAML workflows, and the Renovate GitHub Action itself. Specific presets handle domain-specific updates: \devtool.json5\ groups interdependent Go toolchain and Node version updates; \dex.json5\ and \redis.json5\ automate version bumps for bundled images with post-upgrade tasks to regenerate manifests; \production-binaries.json5\ manages updates for Helm, Kustomize, and Git-LFS with checksum refreshes; and \docs.json5\ groups Python dependencies for documentation. This centralization simplifies individual repository configurations and ensures consistent update policies across the Argo CD ecosystem.

renovate-presets · high confidence

Introduce commit server API client and protocol definitions

Added the \commitserver/apiclient\ package, which provides the Go client implementation and generated protobuf bindings for communicating with the commit server. This includes the \Clientset\ interface for establishing gRPC connections, the \NewConnection\ function for handling transport credentials, and the \CommitHydratedManifestsRequest\ message structure that supports committing hydrated manifests with configurable author details and README updates.

commitserver/apiclient · high confidence

Introduce configurable gRPC message size limits for Config Management Plugins

The Config Management Plugin (CMP) client now supports configuring the maximum gRPC message size via the ARGOCD\_CMP\_GRPC\_MAX\_SIZE\_MB environment variable (defaulting to 100 MB). This allows users to handle larger plugin responses or file streams without hitting gRPC size limits, which is particularly relevant for applications with extensive file structures or large manifest outputs.

cmpserver/apiclient · high confidence

Introduce internal HTTP client for ApplicationSet API calls

Added a new internal HTTP client package in the ApplicationSet service layer to handle API requests. This client supports configurable base URLs, authentication tokens, and custom timeouts, and includes logic to standardize error handling for API responses. Tests verify client creation, request execution with JSON payloads, and proper error reporting for non-2xx status codes.

applicationset/services/internal/http · high confidence

Introduce localized, checksum-verified toolchain installation scripts

The project replaces its previous installation mechanisms with a new set of shell scripts in the \hack/installers\ directory. These scripts install development tools (such as Helm, Kustomize, protoc, golangci-lint, and various Go codegen utilities) into a local \dist\ directory, ensuring a consistent and portable environment. A key addition is the \compare-chksum.sh\ utility, which validates the integrity of downloaded binaries against SHA-256 checksums before installation, enhancing security and reliability. This change centralizes tool versioning and installation logic, making the developer setup more robust and reproducible across different operating systems and architectures.

hack/installers · high confidence

Introduce standalone GitOps Agent CLI and installation manifests

Adds a new standalone GitOps Agent tool (gitops-engine/agent) that provides a CLI interface to sync a single Git repository into the cluster where it is installed, supporting both namespaced and full cluster modes. The change includes the agent's Go implementation (main.go), which leverages the GitOps Engine for reconciliation and sync hooks, and a complete set of Kubernetes installation manifests (install.yaml, install-namespaced.yaml, and Kustomize overlays) for deploying the agent alongside a git-sync sidecar. It also vendors internal Kubernetes utility packages for endpoint sorting and deep hashing to support resource management.

gitops-engine/agent · high confidence

Introduce standalone argocd-k8s-auth CLI for cloud provider authentication

A new standalone CLI tool, argocd-k8s-auth, is introduced to generate Kubernetes authentication tokens for AWS, Azure, and GCP. The tool provides specific subcommands: 'aws' generates presigned STS URLs for EKS (supporting role assumption and AWS profiles), 'azure' leverages kubelogin to acquire access tokens for AKS (with optional POP token support for hybrid clusters), and 'gcp' retrieves default credentials for GKE. This change consolidates cloud-specific auth logic into a dedicated binary, replacing previous integrations within the Argo CD server.

cmd/argocd-k8s-auth · high confidence

Introduces configurable rate limiting for the app controller workqueue

A new rate limiter implementation has been added for the app controller's workqueue, combining a global token bucket with a per-item exponential backoff mechanism. The default configuration disables global bucket limiting (by setting QPS to MaxFloat64) and per-item rate limiting (by setting failure cooldown to 0), meaning the system remains effectively unlimited by default unless explicitly configured. Users can now tune \BucketSize\, \BucketQPS\, and per-item backoff parameters via the \AppControllerRateLimiterConfig\ to control processing throughput and handle failures with auto-resetting exponential delays.

pkg/ratelimiter · high confidence

Introduces new HA installation manifests with Redis HA and hardened security contexts

The \manifests/ha\ directory now provides a complete, self-contained High Availability installation bundle. This includes a new \base/controller-deployment\ kustomization that configures the Application Controller as a StatefulSet (with replicas defaulting to 0 for manual scaling), sets the Repo Server and Argo CD Server to 2 replicas, and applies pod anti-affinity rules to spread pods across nodes and zones. The Redis HA stack is now managed via the \redis-ha\ chart (version 4.35.10) and includes strict security context overlays: containers run as non-root with \readOnlyRootFilesystem\, privilege escalation disabled, and all capabilities dropped. Additionally, a dedicated \secret-init\ container is added to the Redis HA StatefulSet to handle initial password setup, and network policies are explicitly defined to restrict traffic between Argo CD components and the Redis HA proxy/server.

manifests/ha · high confidence

Introduces thread-safe sync ID generation

A new \syncid\ package has been added to provide a mechanism for generating unique, thread-safe identifiers. The implementation combines an atomic counter with a random suffix to ensure uniqueness even under concurrent access, and includes tests to verify this behavior across multiple goroutines.

controller/syncid · high confidence

Introduction of ApplicationSet and AppProject API types

The API package now includes the type definitions for the ApplicationSet and AppProject custom resources. ApplicationSet introduces a declarative way to generate multiple Argo CD applications from a single manifest, supporting generators, sync policies, and progressive rollout strategies. AppProject provides a logical grouping for applications, enabling fine-grained RBAC controls, destination/source whitelists, and role-based JWT token management. These types establish the schema for these core Argo CD features.

pkg/apis/application/v1alpha1 · high confidence

Introduction of dedicated commit server for handling commit requests

A new dedicated commit server has been introduced to handle commit-related requests via gRPC. This server initializes a commit service that can optionally GPG-sign hydrated commits and verify them locally before pushing, based on the provided signing configuration. It also exposes version and health check endpoints, establishing a new architectural component for managing commit operations within the system.

commitserver · high confidence

KEDA ScaledObject and ScaledJob health checks and pause actions

This update adds resource customizations for KEDA ScaledObject and ScaledJob resources. For ScaledObject, the health check now reports 'Suspended' when paused and 'Degraded' when a fallback condition is active, and introduces 'pause', 'resume', and 'paused-replicas' actions to manage scaling state. For ScaledJob, the health check reports 'Suspended' when paused and 'Degraded' when triggers are not working correctly, and provides 'pause' and 'resume' actions.

_resource\customizations/keda.sh · high confidence

MariaDB CRD health checks and suspend/resume actions

Added health-check scripts for MariaDB operator Custom Resource Definitions (Backup, Database, Grant, MariaDB, SqlJob, User) so that Argo CD displays accurate Healthy, Progressing, or Degraded statuses based on the CRD's status conditions. Additionally, introduced suspend and resume actions for the MariaDB CRD, allowing users to pause and resume the operator's reconciliation via the UI.

_resource\customizations/k8s.mariadb.com · high confidence

New ApplicationSet metrics for progressive sync and reconciliation

ApplicationSets now expose Prometheus metrics to monitor progressive sync behavior and reconciliation performance. Users can track the time taken for reconciliation via \argocd\_appset\_reconcile\, monitor the count of application refreshes triggered during progressive sync with \argocd\_appset\_app\_refresh\_total\, and observe sync operations per step using \argocd\_appset\_progressive\_sync\_syncs\_triggered\_total\. Additionally, the health status of applications within each progressive sync step is exposed via \argocd\_appset\_progressive\_sync\_app\_status\, and the latency between detecting applications and triggering their sync is available in \argocd\_appset\_progressive\_sync\_detection\_to\_trigger\_seconds\. General ApplicationSet information, including the number of owned applications, is also available via \argocd\_appset\_info\ and \argocd\_appset\_owned\_applications\.

applicationset/metrics · high confidence

New CLI utility package for application, cluster, and project configuration

A new \cmd/util\ package has been introduced to centralize command-line flag definitions and specification construction for Argo CD resources. This change adds \AppOptions\ and \AddAppFlags\ to support application source configuration, including Helm options (such as \--helm-skip-tests\, \--helm-skip-crds\, and \--ignore-missing-value-files\), Kustomize overrides, and directory settings. It also introduces \ClusterOptions\ and \AddClusterFlags\ to handle cluster registration details like QPS/burst rate limits, proxy URLs, and compression settings, alongside \ProjectOpts\ and \AddProjFlags\ for defining project permissions and resource restrictions. Additionally, it provides \ConstructApplicationSet\ for parsing ApplicationSet manifests from files or URIs, and validation helpers in \common.go\ for bearer tokens and OCI repository security flags.

cmd/util · high confidence

New Deployment actions: restart, pause, resume, and scale

Users can now manage Deployments directly from the UI with four new actions. The Restart action triggers a rolling restart by updating the pod template's restart timestamp. The Pause and Resume actions allow users to temporarily halt or continue a Deployment's rollout by toggling the paused state. Additionally, a new Scale action lets users adjust the number of replicas for a Deployment by specifying a target count.

_resource\customizations/apps/Deployment · high confidence

New Prometheus metrics for Git, OCI, and parallelism control in the repo server

The repo server now exposes a comprehensive set of Prometheus metrics to monitor Git and OCI repository operations. Git metrics include request counts, durations, and failure counters for fetch and ls-remote actions. OCI metrics track request counts, durations, and failures for extract, resolve-revision, digest-metadata, get-tags, and test-repo operations. Additionally, a new histogram metric tracks the time spent waiting for the manifest generation parallelism semaphore, and a configurable environment variable (ARGOCD\_GIT\_LS\_REMOTE\_PARALLELISM\_LIMIT) allows users to limit the parallelism of ls-remote requests to prevent resource exhaustion.

reposerver/metrics · high confidence

New Pull Request Generator services for Azure DevOps, Bitbucket Cloud, Bitbucket Server, Gitea, and GitHub App

The ApplicationSet Pull Request Generator now supports Azure DevOps, Bitbucket Cloud, Bitbucket Server, Gitea, and GitHub App authentication in addition to the existing GitHub and GitLab providers. This change introduces dedicated service implementations for each platform, enabling users to generate applications based on pull requests from these sources. The implementation includes support for filtering by labels, handling pagination, and managing authentication via tokens, basic auth, or bearer tokens where applicable. A new \RepositoryNotFoundError\ type is introduced to handle cases where a repository is not found, allowing the generator to return empty results instead of failing.

_applicationset/services/pull\request · high confidence

New SCM Provider Generators for AWS CodeCommit, Azure DevOps, Bitbucket, and Gitea

The ApplicationSet controller now supports new SCM provider generators for AWS CodeCommit, Azure DevOps, Bitbucket Cloud, Bitbucket Server, and Gitea. These additions allow users to dynamically generate applications from repositories hosted on these platforms, extending the existing support for GitHub and GitLab. The implementation includes specific logic for listing repositories, checking file paths, and retrieving branches for each provider, along with comprehensive test coverage.

_applicationset/services/scm\provider · high confidence

New \`gen-catalog\` CLI tool for generating notifications documentation and catalog

A new \hack/gen-catalog\ command-line tool has been added to the Argo CD codebase. This utility automates the generation of the notifications catalog (install.yaml) and associated documentation (catalog.md, troubleshooting-commands.md) by reading template and trigger definitions from the filesystem. It replaces manual or ad-hoc processes for maintaining these artifacts, ensuring they stay in sync with the built-in notifications-engine definitions.

hack/gen-catalog · high confidence

New account service for local user password management

The API server now exposes a dedicated account service that allows users to update their own password or administrators to change other local users' passwords. This implementation enforces RBAC permissions for cross-user updates, validates new passwords against configurable complexity patterns, and supports SSO users by requiring a fresh token for password changes to ensure the user's identity is current.

server · high confidence

New argocd-git-ask-pass command for git credential retrieval

A new CLI command, argocd-git-ask-pass, has been introduced to handle git credential requests. This utility connects to the Argo CD server via a Unix socket using gRPC to fetch the appropriate username or password based on a nonce, allowing Git and Kustomize operations to authenticate securely without exposing credentials in process lists or logs.

cmd/argocd-git-ask-pass · high confidence

New cluster connection status and label metrics in controller

The controller now exposes \argocd\_cluster\_connection\_status\ to indicate whether each managed Kubernetes cluster is currently connected (1) or disconnected (0), along with \argocd\_cluster\_info\ that includes the cluster name and Kubernetes version. Additionally, if configured, the controller exposes \argocd\_cluster\_labels\ to map custom Kubernetes labels on clusters to Prometheus metrics, providing deeper visibility into cluster connectivity and configuration.

controller/metrics · high confidence

New commit server service for hydrated manifest commits

This change introduces the \commitserver/commit\ package, a new service that handles committing hydrated manifests to Git repositories. It provides the core logic for cloning repositories, writing manifest files, and pushing changes, including support for GPG-signing commits, configurable commit author details, and skipping commits when manifests have not changed. The service also writes \.gitattributes\ and \README.md\ files, and includes a new gRPC API (\CommitService.CommitHydratedManifests\) and Prometheus metrics for tracking commit and Git request performance.

commitserver/commit · high confidence

New consistent hashing sharding implementation with bounded loads

Added a new sharding implementation in the consistent package that supports both standard consistent hashing and the Consistent Hashing with Bounded Loads algorithm. This allows the system to distribute clients across hosts while balancing load more evenly, reducing the risk of hotspots when the number of hosts changes. The implementation uses a B-tree for efficient ring traversal and includes methods to add/remove hosts, get the least loaded host, and update load metrics.

controller/sharding/consistent · high confidence

New dev-mounter tool for syncing Kubernetes ConfigMaps to local folders

A new \hack/dev-mounter\ utility has been added to help developers mount Kubernetes ConfigMaps to local directories during development. This tool watches for ConfigMap changes in the current namespace and automatically creates or updates local files to match the ConfigMap data, while also removing local files that no longer exist in the ConfigMap. It supports authentication for GKE, AKS, and OpenID Connect clusters via standard client-go plugins.

hack/dev-mounter · high confidence

New development toolchain and release automation scripts

The \hack\ directory has been significantly restructured with the addition of numerous new scripts to support the build, release, and testing workflows. This includes \install.sh\ and \tool-versions.sh\ for managing the CI toolchain (Helm, Kustomize, protoc, etc.), \update-manifests.sh\ for generating installation manifests, and \trigger-release.sh\ for orchestrating official releases. Security and compliance are addressed via \snyk-container-tests.sh\, \snyk-non-container-tests.sh\, and \snyk-report.sh\ for vulnerability scanning, alongside \git-verify-wrapper.sh\ and \ssh\_known\_hosts\ for GPG and SSH verification. Developer experience is improved with \goreman-start.sh\ for local service management, \test.sh\ for running tests, and \update-ssh-known-hosts.sh\ for maintaining trusted hosts. Documentation tooling includes \admonitions-to-alerts.sh\ for converting MkDocs callouts to GitHub alerts and \generate-release-notes.sh\ for automating release notes generation.

hack · high confidence

New hack tool to generate known-type normalizers for Kubernetes CRDs

A new \hack/known\_types\ command-line tool has been added to automatically generate Go code that registers known built-in Kubernetes types (such as core/v1 structs and maps) into the application's normalizer registry. By importing a Kubernetes API package path and specifying an alias, users can now produce a \knownTypes\ map initialization file, which ensures that standard K8S types are correctly recognized and normalized during CRD processing without manual registration.

_hack/known\types · high confidence

New repo server API client with configurable TLS, mTLS, and message size limits

The repository server API client has been introduced in the \reposerver/apiclient\ package, providing a new \Clientset\ interface and connection logic for communicating with the repo server. This client supports configurable TLS settings, including optional mTLS with automatic client certificate reloading when files change, and allows users to set the maximum gRPC message size via the \ARGOCD\_GRPC\_MAX\_SIZE\_MB\ environment variable (defaulting to 100 MB). It also integrates retry and timeout interceptors, and OpenTelemetry tracing for improved observability and reliability of repo server interactions.

reposerver/apiclient · high confidence

New resource generation tool for Argo CD test environments

A new set of generators has been added to the \hack/gen-resources/generators\ directory to facilitate the creation of test resources for Argo CD. This includes an ApplicationGenerator that creates random Application resources, a ClusterGenerator that provisions vCluster instances and registers them, a ProjectGenerator for AppProjects, and a RepoGenerator that fetches forked repositories from GitHub to create Secret resources. These tools allow developers to quickly populate a namespace with realistic Argo CD resources for testing purposes.

hack/gen-resources/generators · high confidence

New resource generation utility package with concurrency and configuration support

Added a new \hack/gen-resources/util\ package providing core utilities for the resource generator tool. This includes a YAML-based options parser (\gen\_options\_parser.go\) that supports configuration for applications, clusters, repositories, and projects, with a default concurrency setting of 2. It introduces a \SizedWaitGroup\ (\sizedwaitgroup.go\) to limit concurrent goroutine execution during cluster creation, enabling parallel resource generation. Additional utilities include Kubernetes client connection helpers (\kube.go\), a CLI progress bar (\progress\_bar.go\), and a secure random string generator (\util.go\).

hack/gen-resources/util · high confidence

New reusable interactive prompt utility for CLI commands

A new \Prompt\ utility has been added to the CLI command utilities, providing a centralized way to handle user confirmations. This component supports single confirmations, bulk confirmations with an 'all' option, and context-aware messaging based on item counts. It allows commands to safely gate destructive actions behind user input while respecting a global flag to disable prompts for automation or non-interactive use.

cmd/argocd/commands/utils · high confidence

New sharding cache and multiple distribution algorithms for controller horizontal scaling

The controller/sharding package has been rewritten to support horizontal scaling of the Argo CD application controller. A new sharding cache (cache.go) now tracks clusters and applications to enable dynamic rebalancing and sharding by app. The sharding logic (sharding.go) introduces three distribution algorithms: the original hash-based 'legacy' mode, a 'round-robin' mode for homogeneous distribution, and a new 'consistent-hashing-with-bounded-loads' algorithm that minimizes cluster movement during scaling. These changes allow clusters to be distributed across multiple controller replicas more efficiently and resiliently.

controller/sharding · high confidence

New utility packages for Kubernetes metadata extraction and resource conversion

The \gitops-engine/pkg/utils\ area introduces several new packages to support core engine operations. The \kube/kubemeta\ package provides a high-performance, partial JSON decoder that extracts only the identifying fields (apiVersion, kind, name, namespace) from Kubernetes manifests, significantly reducing memory allocations compared to full unstructured decoding. The \kube\ package adds a \Kubectl\ interface and \KubectlCmd\ implementation for managing Kubernetes resources, including API resource discovery, OpenAPI schema loading, and version conversion. Additionally, the \io\ package provides utility functions for temporary directory handling and file deletion, while the \json\ package introduces logic to remove non-existent fields from live objects during diff calculations. New mock implementations in \kubetest\ are also provided to facilitate testing of these components.

gitops-engine/pkg/utils · high confidence

OpenTelemetry instrumentation for OIDC authentication and new Source Integrity signing capabilities

The OIDC authentication flow now includes OpenTelemetry tracing to provide observability into authentication and handler operations. Additionally, the system introduces Source Integrity features, allowing for the signing of hydrated commits via GPG and the implementation of source integrity checking to verify the authenticity of application sources.

github.com/argoproj/argo-cd/v3 · high confidence

Pause and unpause actions for MonoVertexRollout resources

Users can now pause and unpause MonoVertexRollout resources directly from the UI. The new actions allow setting the lifecycle desired phase to Paused, and resuming with either a fast or gradual strategy. The available resume options are dynamically determined by the \numaflow.numaproj.io/allowed-resume-strategies\ annotation on the underlying MonoVertex, defaulting to gradual if unspecified.

_resource\customizations/numaplane.numaproj.io/MonoVertexRollout/actions · high confidence

Pause/unpause actions and health status mapping for PerconaServerMongoDB

The resource customization for PerconaServerMongoDB now exposes Pause and Unpause actions in the UI, allowing users to toggle the cluster's operational state via the spec.pause field. Additionally, the health indicator logic has been updated to map the cluster's internal state to user-friendly statuses, specifically treating 'paused' as 'Suspended' and 'error' as 'Degraded', ensuring the dashboard accurately reflects the cluster's condition.

_resource\customizations/psmdb.percona.com · high confidence

Repository credential management API and CLI

This change introduces the client-side code generation for the new Repository Credentials Service, enabling users to manage repository credentials via the API and CLI. The diff adds the generated Go protobuf definitions (\repocreds.pb.go\) and the gRPC-Gateway reverse proxy handlers (\repocreds.pb.gw.go\) for the \RepoCredsService\. This service exposes CRUD operations for repository credentials, including listing, creating, and deleting credentials, which allows users to programmatically configure and maintain the credentials Argo CD uses to access Git repositories.

pkg/apiclient/repocreds · high confidence

SpotDeployment health checks now report degraded, suspended, and progressing states

Users deploying Spot.io SpotDeployment resources will now see accurate health status in the UI. The new Lua health script evaluates the resource's status conditions and phase, marking the deployment as 'Degraded' for invalid specs, aborted rollouts, or exceeded deadlines, 'Suspended' when paused, 'Progressing' during rollout, and 'Healthy' otherwise.

_resource\customizations/spot.io · high confidence

Support for GitHub App authentication without explicit installation ID

The GitHub App client now automatically discovers the correct installation ID when one is not explicitly provided, allowing users to configure GitHub App authentication using only the App ID and private key. Previously, an installation ID was strictly required; the new logic uses a shared utility to auto-discover the ID for the specified organization, simplifying the setup process for GitHub App integrations.

_applicationset/services/internal/github\app · high confidence

Removals

Removal of initial API server and version service implementation

The initial API server implementation and the Version Service have been removed from the ArgoCD codebase. This change deletes the \server.go\ file, which previously handled the gRPC and HTTP/1.1+JSON serving logic on port 8080, along with the \version\ package files (\server.go\ and \version.pb.go\) that defined the VersionService gRPC interface and message structures. Users will no longer have access to this specific initial server setup and version endpoint.

argocd · high confidence

Architecture

ApplicationSet controller refactored into modular packages with progressive sync separation

The ApplicationSet controller logic has been reorganized into distinct packages: the main reconciliation loop is now in \controllers/applicationset\_controller.go\, progressive sync logic is isolated in \controllers/progressive\_sync\_dependencies.go\ (implementing the \progressivesync.Dependencies\ interface), and cluster secret event handling is moved to \controllers/clustereventhandler.go\. This separation clarifies responsibilities, keeping progressive sync work within the progressive sync package while providing the controller with minimal, safe access to necessary functionality via the new dependencies interface.

applicationset/controllers · high confidence

Behavioural changes

1 commit (0 fixes) modifying resource\_customizations/secrets.hashicorp.com

A change to existing behaviour in resource\_customizations/secrets.hashicorp.com — 1 commit, 9 files: “feat(health): add health check for Vault Secrets Operator VaultStaticSecret (\#27916) (\#30574)” (refs \#27916, \#30574).

_resource\customizations/secrets.hashicorp.com · medium confidence · unverified

2 commits (1 fix) modifying gitops-engine/pkg/diff/internal

A change to existing behaviour in gitops-engine/pkg/diff/internal — 2 commits (1 fix), 7 files: “fix: resolve HPA v2/v1 conversion error in structured merge diff (\#27809)”; “prepare repo for migration to ArgoCD repo” (refs \#27809).

gitops-engine/pkg/diff/internal · medium confidence · unverified

3 commits (1 fix) modifying gitops-engine/pkg/diff/testdata

A change to existing behaviour in gitops-engine/pkg/diff/testdata — 3 commits (1 fix), 48 files: “chore: add tests to validate ConfigMap/Secret key removal in server-side diff (\#25216)”; “prepare repo for migration to ArgoCD repo”; “fix: server-side diff shows duplicate containerPorts (\#24785)” (refs \#25216, \#24785).

gitops-engine/pkg/diff/testdata · medium confidence · unverified

4 commits (0 fixes) modifying gitops-engine/pkg/diff/mocks

A change to existing behaviour in gitops-engine/pkg/diff/mocks — 4 commits, 1 file: “ci(gitops-engine): support tagged releases for gitops-engine (\#27740)”; “chore: build codegen tools from module files (\#29762)”; “prepare repo for migration to ArgoCD repo”; and 1 more (refs \#27740, \#29762, \#25133).

gitops-engine/pkg/diff/mocks · medium confidence · unverified

API client introduces retryable HTTP transport, configurable gRPC message size, and additional header support

The API client in \pkg/apiclient\ now uses a retryable HTTP client to automatically recover from transient network errors, reducing CLI failures during connection instability. Users can configure the maximum gRPC message size via the \ARGOCD\_GRPC\_MAX\_SIZE\_MB\ environment variable (defaulting to 200 MB) to handle larger payloads. Additionally, the \--additional-headers\ CLI flag allows passing custom HTTP/gRPC headers, and the client now properly closes response bodies on error paths to prevent connection leaks.

pkg/apiclient · high confidence

Add KubeVirt custom health checks for VirtualMachine, VirtualMachineInstance, and DataVolume

This change introduces Lua-based health-check scripts for KubeVirt resources, ensuring the UI accurately reflects their operational state. For VirtualMachines, a VM declared as stopped is now correctly reported as Healthy once the instance is gone, while paused or starting states are handled distinctly. VirtualMachineInstances are assessed by their phase and Ready condition, marking Running instances as Healthy and Paused ones as Suspended. DataVolumes are evaluated by their phase and error conditions, distinguishing between Succeeded (Healthy), Failed/Unknown (Degraded), and Paused (Suspended) states.

_resource\customizations/kubevirt.io · high confidence

Add health checks and actions for Capsule and Project Capsule resources

This update introduces ArgoCD health-check scripts and UI actions for several Capsule and Project Capsule custom resources, including GlobalSopsSecret, SopsProvider, SopsSecret, CapsuleConfiguration, CustomQuota, GlobalCustomQuota, GlobalProxySettings, and GlobalTenantResource. Health is now determined by the resource's Ready condition (Healthy, Degraded, or Progressing), with generation-mismatch detection to show Progressing during reconciliation. For GlobalTenantResource, a cordoned state is explicitly reported as Suspended. Additionally, GlobalTenantResource gains cordon, uncordon, and reconcile actions in the ArgoCD UI to manage replication and trigger updates.

_resource\_customizations/addons.projectcapsule.dev, resource\customizations/capsule.clastix.io · high confidence

Add health checks for AtlasMigration and AtlasSchema resources

Added health-check scripts and test data for the \AtlasMigration\ and \AtlasSchema\ custom resources from \db.atlasgo.io\. The \AtlasMigration\ health script reports \Healthy\ when the \Ready\ condition is true, \Progressing\ while reconciling, and \Degraded\ otherwise. The \AtlasSchema\ health script similarly reports \Healthy\ on success, \Progressing\ during reconciliation or when getting a dev database, and \Degraded\ in other failure states. These changes improve visibility into the status of Atlas operator-managed database migrations and schema definitions.

_resource\customizations/db.atlasgo.io · high confidence

Add health checks for Karmada ClusterResourceBinding and ResourceBinding

This change introduces Lua-based health-check scripts for the \ClusterResourceBinding\ and \ResourceBinding\ custom resources in the \work.karmada.io\ API group. The scripts evaluate the \status.aggregatedStatus\ to report \Healthy\, \Degraded\, or \Progressing\ states, ensuring that bindings are considered healthy only when all target clusters have reported back and are healthy. A specific behavioral fix is included for \ResourceBinding\: bindings created via dependency propagation (where \spec.clusters\ is absent) are no longer incorrectly marked as \Progressing\ due to missing cluster specs, allowing their health to be evaluated directly from \aggregatedStatus\. Test data and validation tests are added to cover these scenarios.

_resource\customizations/work.karmada.io · high confidence

Add health checks for Trident Orchestrator and BackendConfig resources

Users deploying NetApp Trident via Kubernetes Custom Resources now receive accurate health status indicators in the UI. This change introduces Lua-based health scripts for the \TridentOrchestrator\ and \TridentBackendConfig\ CRDs. For \TridentOrchestrator\, the resource is marked Healthy when the status is 'Installed', Degraded for 'Failed' or 'Error', and Progressing otherwise. For \TridentBackendConfig\, the resource is Healthy when the phase is 'Bound' and the last operation was 'Success', Degraded on 'Failed' operations, and Progressing while waiting for backend creation.

_resource\customizations/trident.netapp.io · high confidence

Add health status checks for Kiali custom resources

Users can now see the health status of Kiali resources in the UI. A new Lua script evaluates the \status.conditions\ of \Kiali\ CRs, mapping \Successful\ conditions to Healthy, \Failure\ conditions to Degraded, and \Running\ conditions to Progressing. Test data and test cases have been added to verify this behavior.

_resource\customizations/kiali.io · high confidence

ApplicationSet controller reliability and caching improvements

This change introduces a cache-syncing client wrapper that ensures the Kubernetes informer cache is updated immediately after Create, Update, Patch, or Delete operations on Application objects, preventing stale cache entries from blocking reconciliation. It also adds a new ApplicationSet lister implementation using the controller-runtime client, refactors cluster listing utilities to use a dedicated ClusterSpecifier struct, and introduces a \tpl\ function for nested Go templating within ApplicationSets. Additionally, the \ignoreApplicationDifferences\ logic is hardened to correctly neutralize ignored fields regardless of TypeMeta presence, and sync policies are now explicitly registered in a utility map for consistent resolution.

applicationset/utils · high confidence

ApplicationSet generators refactored into modular, testable components

The ApplicationSet generator logic has been restructured into distinct, single-responsibility files (cluster, duck\_type, git, list, generator\_spec\_processor) with a clean Generator interface, enabling better maintainability and testability. This change introduces a new FlatList option for the Cluster Generator to flatten output, adds support for ElementsYaml in the List Generator for dynamic content, and fixes a panic in the DuckType Generator when encountering non-string values. It also corrects post-generator selector matching in GoTemplate mode by properly flattening nested map parameters, and ensures the Git Generator respects Source Integrity policies from associated AppProjects.

applicationset/generators · high confidence

ApplicationSet progressive sync: fixes for reverse deletion, spec-change reporting, and validation messaging

The progressive sync logic for ApplicationSets has been refactored into its own package and hardened with several behavioral fixes. Reverse deletion now verifies terminating children against the live API server rather than trusting the informer cache alone, preventing the ApplicationSet finalizer from being released while children are still terminating and avoiding infinite loops caused by phantom cache entries. The status reporting for spec changes has been corrected to ignore controller-managed mutations (such as \automated.enabled\) and to respect \ignoreApplicationDifferences\ rules, stopping false-positive "spec differs" errors that previously blocked progression. Additionally, the system now surfaces detailed validation issues—such as invalid match expressions, duplicate app selections, empty steps, and invalid \maxUpdate\ values—directly in the ApplicationSet condition messages, and ensures the reconciler does not spin in a tight loop when applications are not yet reconciled.

applicationset/progressivesync · high confidence

Argo CD CLI now hides unsupported kubectl REST flags

The \argocd\ CLI now filters out specific kubectl REST flags that are not supported by the Argo CD API server, preventing user confusion or errors when using kubectl-style options. The \initialize\ command now explicitly excludes flags such as \--tls-server-name\, \--certificate-authority\, \--client-certificate\, \--client-key\, \--as\, \--as-group\, \--as-uid\, and \--disable-compression\ from the available command-line interface, while still exposing standard flags like \--context\ and \--namespace\. This change ensures that the CLI presents only the flags that are actually functional within the Argo CD context.

cmd/argocd/commands/initialize · high confidence

Argo CD Repository Server v3: New command structure with configurable TLS, OpenTelemetry, and OCI support

The repository server command has been rewritten for the v3 release, introducing a new CLI structure that supports configurable TLS (including a new --disable-tls flag and mutual TLS via --client-ca-path), OpenTelemetry tracing with secure endpoints and custom headers, and beta OCI registry support. The server now allows custom User-Agent headers for Helm requests, configurable ask-pass socket paths, and stricter symlink validation to block out-of-bounds links. Additionally, it features graceful shutdown handling, JSON logging by default, and improved manifest generation caching and concurrency controls.

cmd/argocd-repo-server · high confidence

Argo CD v3 CLI command structure and account management overhaul

The CLI in the \cmd/argocd/commands\ package has been restructured for Argo CD v3, introducing a new \argocd account\ command group that consolidates user management operations such as password updates, token generation, and RBAC checks (\can-i\). The \argocd app\ command set has been expanded with new subcommands for managing multi-source applications (\add-source\, \remove-source\) and executing custom resource actions (\actions list\, \actions run\). Additionally, the application creation workflow now supports an \--app-namespace\ flag to deploy applications into namespaces other than the CLI's default, and the \app diff\ command has been refactored to support server-side diffing capabilities.

cmd/argocd/commands · high confidence

Automated static schema parser generation for Linux

A new shell script, update\_static\_schema.sh, has been added to the hack directory to automate the generation of the static schema parser. This script fetches the internal parser code from the kubernetes/client-go library based on the version specified in go.mod, downloads it to pkg/utils/kube/scheme/parser.go, and adjusts the package and function names to fit the local project structure. This change ensures the static schema parser remains synchronized with the upstream Kubernetes client-go library.

gitops-engine/hack · high confidence

Cassandra Cluster health status now reflects rack readiness

The health check for Rook Cassandra clusters has been updated to evaluate the readiness of individual racks. The system now reports a 'Healthy' status only when all rack members are ready; otherwise, it reports 'Progressing' with the message 'Waiting for Cassandra Cluster'. This provides clearer visibility into the deployment state of Cassandra clusters within the UI.

_resource\customizations/cassandra.rook.io · high confidence

Centralize Argo CD constants and enhance version reporting

The \common\ package now consolidates Argo CD configuration constants, including component names, default service addresses (such as repo-server, commit-server, and Dex), Kubernetes resource names, listener ports, and application metadata labels. Version reporting has been expanded to include \KubectlVersion\ and vendor-specific \ExtraBuildInfo\, and a new \LogStartupInfo\ method standardizes how component startup messages are logged across the system.

common · high confidence

Custom health status for cert-manager Issuer resources

Argo CD now displays specific health statuses for cert-manager Issuer resources instead of a generic state. The new health check script evaluates the Issuer's Ready condition: it reports 'Healthy' when the ACME account is registered, 'Degraded' with the error message if registration fails, and 'Progressing' while initializing or if no status is present yet. This provides clearer visibility into the lifecycle and potential issues of ACME issuers within the application tree.

_resource\customizations/cert-manager.io/Issuer · high confidence

Expand RBAC role to create application events and fix username claims extraction

The RBAC role has been expanded to allow users to create application events, enabling more granular audit and activity tracking within the system. Additionally, a fix for username claims extraction ensures that user identity is correctly resolved during authentication, preventing potential issues with user attribution in logs and access controls.

(repo-wide) · high confidence

Exposes notification controller processor count via command-line flag

The Argo CD Notifications controller now allows users to configure the number of concurrent processing workers via the new \--processors-count\ flag (and the \ARGOCD\_NOTIFICATION\_CONTROLLER\_PROCESSORS\_COUNT\ environment variable). This change enables operators to tune the controller's concurrency and throughput to better match their workload, moving away from the previous hardcoded default of 1 processor.

cmd/argocd-notification · high confidence

Flagger Canary health status reporting

The resource customization for \flagger.app/Canary\ resources now includes a Lua script that maps the custom resource's \status.phase\ to user-friendly health statuses. Users will see 'Healthy' for Succeeded/Initialized phases, 'Progressing' for Progressing/Finalising/Promoting phases, and 'Degraded' for Failed phases, with messages that include the canary weight and condition details. This change improves visibility into the state of Flagger canary deployments within the UI.

_resource\customizations/flagger.app · high confidence

Generated API client code for account service moved to pkg/apiclient/account

The generated Go code for the account service API client (including protobuf definitions and gRPC-gateway reverse proxy handlers) has been relocated to the \pkg/apiclient/account\ package. This change updates the import paths and package structure for clients interacting with account-related gRPC endpoints such as \UpdatePassword\, \CanI\, \ListAccounts\, and \GetAccount\, ensuring the generated code is now consumed from this new location.

pkg/apiclient/account · high confidence

Generated repository API client code regenerated for v3

The generated Go code for the repository gRPC client and its REST gateway proxy has been regenerated. This update aligns the \pkg/apiclient/repository\ package with the current \server/repository/repository.proto\ definition, ensuring that the API client structures (such as \RepoAppsQuery\ and \RepoAppDetailsQuery\) and the HTTP-to-gRPC translation layer are consistent with the service interface.

pkg/apiclient/repository · high confidence

GitOps engine v3 sync logic and hook handling

The \gitops-engine/pkg/sync\ package has been restructured and updated for the v3 release, introducing a new high-level \GitOpsEngine\ interface in \pkg/engine\ that orchestrates the sync process. This change brings comprehensive support for Helm-style hooks (mapping \helm.sh/hook\ annotations to Argo CD sync phases) alongside existing Argo CD hooks, including specific handling for Helm delete policies and weights. The sync context now exposes explicit options for controlling resource pruning (\WithPrune\, \WithDefaultPruneOption\) and includes robust logic for reconciling target and live resources, deduplicating live objects, and managing hook finalizers to ensure clean deletion after sync phases complete.

gitops-engine/pkg/sync · high confidence

Improved health reporting for AWS EKS control planes

Added a custom health check for the AWSManagedControlPlane resource that prevents the control plane from being reported as Healthy while an in-place EKS update is in progress. The new logic also surfaces terminal failures via .status.failureMessage and correctly reports Progressing when the observed generation is stale, ensuring that users see accurate status during updates or when the provider has not yet reconciled the latest spec.

_resource\customizations/controlplane.cluster.x-k8s.io · high confidence

Improved health status reporting for Keycloak resources

The health check logic for Keycloak custom resources now correctly handles status conditions that have a nil \lastTransitionTime\ by sorting them to the end of the list, preventing potential errors during health evaluation. Additionally, the system now explicitly reports a "Progressing" status when status conditions are missing entirely, providing clearer visibility into the resource's state during initial provisioning.

_resource\customizations/k8s.keycloak.org · high confidence

Introduce Lua-based health checking for Argo Rollouts

Argo CD now uses a Lua script to determine the health status of Argo Rollouts resources, replacing previous static or less granular checks. This new health check logic accurately maps Rollout states to Argo CD statuses, including reporting 'Suspended' for paused rollouts (supporting both spec.paused and pauseConditions), 'Degraded' for invalid specs, aborted rollouts, or timeouts, and 'Progressing' for various stages of blue-green and canary strategies. It also handles version-specific nuances, such as observed generation checks for v0.10+ and workload generation for v1.1+, ensuring correct health reporting across Argo Rollouts versions from v0.8 through v1.1.

_resource\customizations/argoproj.io/Rollout · high confidence

MariaDB CRD health checks now report degraded and progressing states

The MariaDB resource customization now includes a Lua health script that evaluates the \status.conditions\ of MariaDB resources to provide more granular status reporting. Instead of a generic state, the system now distinguishes between 'Healthy', 'Progressing', and 'Degraded' states based on specific condition reasons such as 'Failed', 'RestoreNotComplete', or 'StatefulSetNotReady'. This allows users to see detailed messages like 'Error creating ConfigMap' or 'Restoring backup' directly in the resource status, improving visibility into the lifecycle and health of MariaDB instances.

_resource\customizations/mariadb.mmontes.io · high confidence

Migrate admin CLI commands to v3 module structure

The \argocd admin\ CLI subcommands (including app, cluster, backup/export-import, dashboard, and settings) have been restructured into the \cmd/argocd/commands/admin\ package under the v3 module path (\github.com/argoproj/argo-cd/v3\). This change updates internal imports to use the v3 package structure, reflecting the major version bump to v3, and introduces new flags such as \--application-namespaces\ and \--applicationset-namespaces\ for the export command to support multi-namespace application management.

cmd/argocd/commands/admin · high confidence

MinIO Tenant health status reporting

The MinIO Tenant resource now displays accurate health status in the UI, mapping internal states like 'Initialized' to Healthy, and states such as 'Provisioning', 'Updating', and 'Restarting MinIO' to Progressing. Error conditions including credential issues, version mismatches, and operator control problems are now correctly reported as Degraded, providing clearer visibility into the tenant's operational state.

_resource\customizations/minio.min.io · high confidence

New controller cache implementation with configurable tuning and security hardening

The application controller's cluster state cache has been replaced with a new implementation that introduces several environment variables for tuning performance and stability, including \ARGOCD\_CLUSTER\_CACHE\_RESYNC\_DURATION\, \ARGOCD\_CLUSTER\_CACHE\_LIST\_PAGE\_SIZE\, and \ARGOCD\_CLUSTER\_CACHE\_BATCH\_EVENTS\_PROCESSING\. This change also adds security hardening by validating external URLs from resource annotations to prevent XSS attacks via \javascript:\ or \data:\ schemes, and updates the cache to support newer Kubernetes API versions and Gateway API resources.

controller/cache · high confidence

New health assessment logic for Kubernetes resources

The gitops-engine now includes a comprehensive, built-in health assessment system for core Kubernetes resources, replacing previous implicit or missing checks. This change introduces specific health logic for Deployments, StatefulSets, DaemonSets, ReplicaSets, Jobs, Pods, Services, Ingresses, PersistentVolumeClaims, HorizontalPodAutoscalers (v1 and v2), APIServices, and Argo Workflows. Users will see more accurate status reporting, such as Jobs correctly reflecting a 'Suspended' state with their condition messages, HPAs reporting degraded states for metric retrieval failures, and Pods respecting the \ignoreRestartPolicy\ annotation to avoid premature hook failures. The system also standardizes rollout progress messages for workloads and handles custom deletion messages for terminating resources.

gitops-engine/pkg/health · high confidence

New modular cache implementation for the repo server

The repository server now uses a dedicated, modular cache package (reposerver/cache) to manage manifest generation, application listing, and revision metadata. This change introduces configurable expiration times for repository state and revision caches via command-line flags, and implements JSON serialization for cache entries to replace the previous binary format. The new structure also includes specific handling for multi-source application references and cluster runtime information to ensure cache keys accurately reflect the underlying Git revisions and Kubernetes API versions.

reposerver/cache · high confidence

Notification controller now supports multi-namespace monitoring and self-service configuration

The notification controller has been updated to monitor Application resources across multiple namespaces (not just its own) when configured via \applicationNamespaces\, allowing notifications for apps in other namespaces. Additionally, when self-service notifications are enabled, the controller now reads notification configuration from all namespaces (\metav1.NamespaceAll\) rather than being restricted to the controller's own namespace. The controller also ensures thread-safety by deep-copying AppProject objects retrieved from the shared informer cache before use, preventing concurrent mutation issues.

_notification\controller · high confidence

Optimized application list API with streaming and field filtering

The application list API now streams JSON responses directly to the client and supports field filtering, significantly reducing memory usage and payload size when listing applications. This change introduces a custom forwarder that extracts only the requested fields (such as metadata, sync status, and health) from the application list, avoiding the overhead of marshaling full application objects. The implementation includes generated gRPC gateway code and a new forwarder module that handles field selection and streaming, ensuring efficient handling of large application lists.

pkg/apiclient/application · high confidence

PodDisruptionBudget health checks now ignore InsufficientPods conditions

The health status evaluation for PodDisruptionBudget resources has been updated to no longer mark the resource as Degraded when the DisruptionAllowed condition is False with the reason InsufficientPods. Previously, this condition triggered a degraded state, but it is now treated as a valid, non-error state (Healthy or Progressing depending on other conditions). This change prevents false-positive health alerts when the budget cannot be satisfied due to insufficient available pods, while still correctly reporting other failure reasons like SyncFailed as Degraded.

_resource\customizations/policy · high confidence

Refactored repository service with new locking and chart details extraction

The repository service implementation has been restructured to improve concurrency and code organization. A new \repositoryLock\ mechanism (lock.go) manages concurrent access to repository paths, allowing parallel processing for the same revision when configured while ensuring exclusive access for different revisions or non-concurrent operations. Additionally, a new \getChartDetails\ function (chart.go) extracts Helm chart metadata such as description, home URL, and maintainers from the Chart.yaml file, supporting the exposure of chart information in the UI and API.

reposerver/repository · high confidence

Regenerated API client code for Project and Session services

The generated Go code for the Project and Session API clients has been regenerated, introducing new request types such as ProjectTokenCreateRequest and ProjectTokenDeleteRequest, and updating the Session service to include a GetUserInfo endpoint. Additionally, the Project service client now uses a typed HTTP forwarder from the argoproj/pkg library to handle gRPC-to-REST translation.

pkg/apiclient/project · high confidence

Regenerated SCM provider mocks for AWS and Azure SDKs

The mock implementations in the \applicationset/services/scm\_provider/mocks\ directory have been regenerated using \mockery\ v3.8.0 to align with the migration to \aws-sdk-go-v2\. This update refreshes the \AWSCodeCommitClient\ and \AWSTaggingClient\ mocks to use the new AWS SDK v2 service packages (\codecommit\ and \resourcegroupstaggingapi\) and adopts the new \Expecter\ struct pattern for defining test expectations. The \AzureDevOpsClientFactory\ mock was also regenerated to ensure consistency with the updated tooling.

_applicationset/services/scm\provider/mocks · high confidence

Removal of internal error-checking utility

The internal \CheckError\ helper function, which previously terminated the application via log.Fatal on non-nil errors, has been removed from the codebase. This change eliminates a specific error-handling pattern, requiring callers to manage error states explicitly rather than relying on this automatic exit mechanism.

errors · high confidence

Removal of the legacy cmd/argocd main entry point

The standalone main.go file in the cmd/argocd directory has been deleted. This change removes the previous entry point that directly instantiated and executed the Argo CD commands, indicating a shift in how the binary is built or initialized, likely consolidating the build process as suggested by related commit history.

cmd/argocd · medium confidence

Repo server now supports mTLS with robust GPG keyring watching

The repo server now enforces mutual TLS (mTLS) when a client CA path is provided, automatically generating an ephemeral health-check client certificate so that liveness probes can connect to the server without being rejected. Additionally, a new GPG watcher (gpgwatcher.go) monitors the source directory for file changes and syncs the GPG keyring, with improved robustness to handle directory recreation events during testing or runtime.

reposerver · high confidence

Resource customizations are now embedded via Go's embed package

The resource customization files are now embedded directly into the binary using Go's standard \embed\ package, replacing the previous external packaging method. This change simplifies the build process and ensures that customization resources are always available within the application without requiring separate file lookups.

_resource\customizations · high confidence

SecretStore health check now reports Ready status

The tooling now evaluates the health of external-secrets.io SecretStore resources by inspecting their status conditions. When a SecretStore's Ready condition is True, it is reported as Healthy; when False, it is reported as Degraded with the associated message; otherwise, it remains in a Progressing state. This allows users to see the operational status of their secret stores directly in the UI or CLI.

_resource\customizations/external-secrets.io/SecretStore · high confidence

Server-side diff now defaults to Server-Side Diff (SSD) and removes Structured Merge Diff (SMD)

The diff engine in gitops-engine now defaults to using Server-Side Diff (SSD) for resources with the Server-Side Apply sync option, replacing the previously used Structured Merge Diff (SMD) strategy. This change is implemented in the \gitops-engine/pkg/diff\ package, where the \Diff\ function now checks for the \ServerSideApply=true\ annotation and, if a dry-run runner is available, executes a server-side apply in dry-run mode to calculate the diff. The SMD strategy has been removed, and the codebase now relies on the \ServerSideDryRunner\ interface and borrowed Kubernetes fieldmanager code to handle server-side diffing, ensuring more accurate diffs that align with Kubernetes' server-side apply behavior.

gitops-engine/pkg/diff · high confidence

SparkApplication health checks now support dynamic executor allocation

The health check script for SparkApplication resources has been updated to correctly evaluate health status when dynamic allocation is enabled. Previously, the check required a fixed number of executor instances; the new logic supports both operator API configuration (spec.dynamicAllocation) and Spark configuration properties (spark.dynamicAllocation.enabled and spark.streaming.dynamicAllocation.enabled). It validates that the number of running executor pods falls within the configured min/max range, or accepts any running count if no specific configuration is provided, ensuring accurate Healthy/Progressing/Degraded status reporting for dynamic workloads.

_resource\customizations/sparkoperator.k8s.io · high confidence

Switch default logging to JSON format

The default log output format for the API server, repository server, and controller has changed from plain text to JSON. This improves machine-readability and integration with log aggregation systems, though users who rely on the previous human-readable plain text format will need to explicitly configure the log format to revert to it.

util · high confidence

Unified Argo CD binary dispatches to specific subcommands based on binary name

The Argo CD CLI now uses a single consolidated binary that determines which component to run (CLI, API server, application controller, repo server, CMP server, commit server, Dex, notifications, git-ask-pass, or application set controller) by inspecting the binary's name at runtime. This allows users to install a single binary and access all Argo CD functionalities through name-based dispatching, while also improving plugin error handling by silencing initial errors and usages for plugin-invoked commands.

cmd · high confidence

Updated ApplicationSet Git Generator examples with Go template support and exclusion patterns

The examples in the ApplicationSet Git Generator directory have been updated to demonstrate the new Go template syntax, including the use of \goTemplate: true\ and \goTemplateOptions: \["missingkey=error"\]\ for stricter variable handling. The examples now show how to exclude specific directories from generation using the \exclude: true\ flag, and they reference the \argocd-e2e-container\ image instead of the deprecated \heptio-images\. Additionally, new Helm chart and Kustomize configurations for Argo Workflows and Prometheus Operator are included to provide complete, runnable examples for deploying cluster addons.

applicationset/examples/git-generator-directory · high confidence

Version API endpoint moved to /api/version and expanded with vendor build info

The version service has been relocated from the root path to the /api prefix (now accessible at /api/version), and the response payload now includes an ExtraBuildInfo field to support vendor-specific build metadata. Additionally, the generated gRPC-Gateway code has been updated to use the modern gRPC metadata package and standard context imports, ensuring compatibility with current gRPC libraries.

pkg/apiclient/version · high confidence

Fixes

Add health status checks for ConfigConnector resources

This change introduces a new health check script for ConfigConnector and ConfigConnectorContext resources, allowing the system to correctly report their status based on the \status.healthy\ field and \observedGeneration\. It also adds corresponding test cases to verify that healthy, degraded, and stale states are accurately detected for these specific resource types.

_resource\customizations/\.cnrm.cloud.google.com · high confidence_

CustomResourceDefinition health checks now distinguish installation from degradation

The health check logic for CustomResourceDefinitions has been updated to prevent false 'Degraded' status reports during the initial installation phase. Previously, a CRD with an 'Established' condition and reason 'Installing' was incorrectly marked as degraded; it is now correctly reported as 'Progressing' with the message 'CRD is being installed'. The check also explicitly handles other states such as termination, missing conditions, schema violations, and name acceptance issues, providing clearer status messages for each scenario.

_resource\customizations/apiextensions.k8s.io · high confidence

Ensure UI assets directory exists for Go embed in CI

Added a 'gitkeep' file to the ui/dist/app directory to ensure the compiled UI assets folder is tracked in Git. This prevents Go build failures in backend-only CI jobs (which run 'make build-local') by providing a non-hidden file for the 'go:embed' directive to reference when the UI has not yet been built. A '.gitkeep' file was also added to the images/resources directory to maintain the directory structure in the repository.

ui/dist · high confidence

Fix pod log viewer crash on malformed stream packets

The pod log viewer in the UI no longer crashes when it receives malformed stream packets from the backend. This fix improves stability and ensures that log viewing remains uninterrupted even when encountering unexpected data formats in the log stream.

ui · high confidence

Headless mode now correctly respects the specified Kubernetes context

The headless CLI mode (which runs the Argo CD API server in-process) now properly honors the \--kube-context\ flag. Previously, the in-process server might ignore the user's selected context and fall back to a default, causing commands to target the wrong cluster. This change ensures that when core mode is enabled, the local API server and its associated cache/repo clients are configured to use the exact Kubernetes context specified by the user, aligning headless behavior with standard CLI expectations.

cmd/argocd/commands/headless · high confidence

Improved health status reporting for cert-manager Certificate resources

Added a custom health check script for cert-manager Certificate resources that correctly distinguishes between 'Progressing', 'Degraded', and 'Healthy' states. The logic prioritizes the 'Issuing' condition to ensure consistent behavior, and specifically handles a race condition where the 'Ready' condition is set to False with an 'Issuing' message before the 'Issuing' condition type is added, preventing false 'Degraded' alerts during certificate issuance.

_resource\customizations/cert-manager.io/Certificate · high confidence

New cluster cache implementation with configurable manifest serialization and memory safety fixes

The \gitops-engine/pkg/cache\ package has been replaced with a new implementation that introduces configurable serialization (JSON, JSONIter, MsgPack) and compression (GZip, S2, ZLib) for cached resource manifests, allowing users to optimize memory usage and performance. This update also fixes critical stability issues: it prevents panics when list operations return nil errors by ensuring empty lists are returned, eliminates memory retention of list pages during cache initialization by using \EachListItemWithAlloc\, and resolves stack overflows caused by circular owner references in the resource graph.

gitops-engine/pkg/cache · high confidence

OpenTelemetryCollector health check now correctly handles DaemonSet and Sidecar modes

The health status for OpenTelemetryCollector resources is now determined by a new Lua script that parses the \statusReplicas\ field. This change ensures that DaemonSet deployments showing 0/0 replicas are correctly reported as Healthy (since no nodes may be eligible), rather than Degraded. It also adds specific handling for Sidecar mode, reporting it as Healthy immediately, and properly distinguishes between Progressing, Healthy, and Degraded states for standard deployments based on ready versus total replica counts.

_resource\customizations/opentelemetry.io · high confidence

Test coverage

Added GPG Key Service client mock for testing; Added RBAC and ClusterRole test fixtures for admin commands; Added RepoClientFactory mock for testing; Added autogenerated mock for Azure DevOps Git client; Added controller test fixtures for health checks, diff caching, and resource schemas; Added mock implementations for hydrator dependencies; Added mock repository cache for testing; Added mocks for CommitServiceClient to support source hydration testing; Added podinfo Helm chart test data; Added test fixtures for CLI plugin support; Added webhook payload test fixtures for Azure DevOps and GitHub events; Auto-generated mock for LiveStateCache interface; New E2E test fixture for Argo CD application lifecycle; Regenerated ApplicationServiceClient mock for updated API signatures; Regenerated Generator mock using mockery v3; Regenerated ProjectServiceClient mock for updated API signatures; Regenerated Renderer mock using mockery v3; Regenerated cluster service mocks for v3 API; Regenerated mock implementations for the repo-server API client; Regenerated session service mocks for v3 API client; Updated ClusterCache mock to use Expecter structs; Updated Gitea test fixtures to resolve flaky tests; Updated mock for Repos service to support source integrity checks; Updated test infrastructure base images and tooling.

Dependencies

Routine dependency updates across 9 manifests

This release updates dependencies across 9 manifests, including bumps to the Go JSON query library (gojq), the authorization engine (casbin), the Gitea SDK, AWS SDK configuration, the Foundation UI framework, the Kubernetes OpenAPI library, the Go networking library, Markdown processing, Jest types, Python Markdown extensions, AWS Smithy, GitHub installation client, Logrus, Prometheus client, React SVG pie chart, Kubelogin, GitLab API client, AWS SDK, Govaluate, OpenTelemetry libraries, file system notifications, and Azure SDK identity. These updates bring in upstream improvements and fixes.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 56 → 58 (+2.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 78 → 76 (-2.5)
  • Architecture 77 → 74 (-3.5)
  • Maturity 72 → 72 (+0.0)
  • Readiness 65 → 65 (+0.2)
  • Security 64 → 65 (+1.2)
  • Accessibility 43 → 47 (+4.1)
  • Performance 77 → 95 (+17.7)

Resolved (47)

  • ClassTooLong: clusterCache (gitops-engine/pkg/cache/cluster.go)
  • Duplicated block (10 lines × 2) (cmd/argocd/commands/admin/cluster.go)
  • Duplicated block (10 lines × 2) (gitops-engine/pkg/cache/cluster.go)
  • Duplicated block (14 lines × 2) (cmd/argocd/commands/admin/backup.go)
  • Duplicated block (5 lines × 2) (cmd/argocd/commands/admin/backup.go)
  • Duplicated block (5 lines × 2) (gitops-engine/pkg/cache/cluster.go)
  • Duplicated block (6 lines × 2) (gitops-engine/pkg/diff/diff.go)
  • Duplicated block (6 lines × 3) (gitops-engine/pkg/utils/kube/ctl.go)
  • Duplicated block (8 lines × 2) (gitops-engine/pkg/cache/settings.go)
  • Duplicated block (8 lines × 2) (util/kube/kube.go)
  • FixmeComment (util/exec/exec_norace_test.go)
  • FixmeComment repeated across 18 files (applicationset/generators/scm_utils.go)
  • High CVE: [GHSA redacted] (ui/pnpm-lock.yaml)
  • Hotspot: applicationset/progressivesync/progressive_sync.go (applicationset/progressivesync/progressive_sync.go)
  • Hotspot: server/application/application.go (server/application/application.go)
  • Hotspot: server/server.go (server/server.go)
  • Hotspot: server/settings/settings.go (server/settings/settings.go)
  • Hotspot: util/settings/settings.go (util/settings/settings.go)
  • Hotspot: util/webhook/webhook.go (util/webhook/webhook.go)
  • Low CVE: [GHSA redacted] (ui/pnpm-lock.yaml)
  • …and 27 more

New (233)

  • AppProject.isDestinationMatched (cognitive 22) (pkg/apis/application/v1alpha1/app_project_types.go)
  • AppProject.isDestinationMatched (cyclomatic 22) (pkg/apis/application/v1alpha1/app_project_types.go)
  • ApplicationController.persistAppStatus (cyclomatic 29) (controller/appcontroller.go)
  • ApplicationController.statusWithEffectiveReconciledAt (cognitive 20) (controller/appcontroller.go)
  • ClassTooLong: store (gitops-engine/pkg/cache/cluster.go)
  • Duplicated block (10 lines × 2) (gitops-engine/pkg/cache/legacy_engine.go)
  • Duplicated block (12 lines × 2) (server/application/application.go)
  • Duplicated block (16 lines × 2) (cmd/argocd/commands/admin/backup.go)
  • Duplicated block (5 lines × 2) (gitops-engine/pkg/cache/legacy_engine.go)
  • Duplicated block (7 lines × 2) (gitops-engine/pkg/cache/legacy_engine.go)
  • Duplicated block (8 lines × 2) (gitops-engine/pkg/cache/settings.go)
  • Duplicated block (8 lines × 2) (gitops-engine/pkg/sync/sync_context.go)
  • Duplicated block (8 lines × 2) (reposerver/repository/repository.go)
  • Duplicated block (9 lines × 2) (util/kube/kube.go)
  • Edited copies of one member (3 members, 10+ corresponding lines) (util/kube/kube.go)
  • Edited copies of one member (3 members, 11+ corresponding lines) (server/certificate/certificate.go)
  • Edited copies of one member (3 members, 12+ corresponding lines) (gitops-engine/pkg/cache/cluster.go)
  • Edited copies of one member (3 members, 13+ corresponding lines) (cmd/argocd/commands/project_source_integrity.go)
  • Edited copies of one member (3 members, 13+ corresponding lines) (server/notification/notification.go)
  • Edited copies of one member (3 members, 14+ corresponding lines) (gitops-engine/pkg/health/health_pod.go)
  • …and 213 more

Changes since last survey

  • 186 commits — 118 feature/other, 68 fixes

By area

  • ui/src — 37 commits
  • (root) — 32 commits
  • docs/operator-manual — 14 commits
  • .github/workflows — 13 commits
  • gitops-engine/pkg — 7 commits
  • util/git — 7 commits
  • docs/requirements.txt — 4 commits
  • test/e2e — 4 commits
  • applicationset/services — 3 commits
  • cmd/argocd — 3 commits
  • docs/snyk — 3 commits
  • pkg/apiclient — 3 commits
  • server/application — 3 commits
  • ui/pnpm-lock.yaml — 3 commits
  • applicationset/generators — 2 commits
  • docs/proposals — 2 commits
  • docs/user-guide — 2 commits
  • hack/tools — 2 commits
  • manifests/ha — 2 commits
  • pkg/apis — 2 commits

Notable commits

  • fix: fix(actions): list Rollout actions when the Rollout has no status (#30291) (#30331)
  • fix: fix(app): ensure deletion message is printed only for text output fomat (#30600)
  • fix: fix(appset): do not expose reserved cluster annotations as parameters (#30448)
  • fix: fix(appset): list generator returns corrupted error for non-string element values (#30855)
  • fix: fix(appset): make ParametersGenerated condition message consistent (#30405) (#30438)
  • fix: fix(appset): refresh GitLab pull request generators configured with the project path (#13766) (#30578)
  • fix: fix(build): disable Go VCS stamping for untagged builds (#30931) (#30932)
  • fix: fix(cli): accept write-repositories in 'argocd admin settings rbac can' (#30457) (#30458)
  • fix: fix(cli): honor HTTP_PROXY/HTTPS_PROXY/NO_PROXY for gRPC-web connections (#29642)
  • fix: fix(cli): send --header values when refreshing an expired auth token (#30061) (#30062)
  • fix: fix(controller): allow terminating an operation blocked by a sync window (#26395) (#30267)
  • fix: fix(controller): honor manifest-generate-paths for shallow-cloned repositories (#30485)
  • fix: fix(controller): skip the diff cache after an Unknown sync status (#28722) (#30893)
  • fix: fix(exec): bound how long RunCommandExt waits for output pipes to close (#30395)
  • fix: fix(exec): fix data race on output buffers when a command times out (#30396)
  • fix: fix(git): use configurable timeout for GitHub App installation discovery (#30601)
  • fix: fix(gitops-engine): release events and handle UID changes in cache (#30705)
  • fix: fix(gitops-engine): stop retaining the decoded OpenAPI document per cluster (#30810) (#30811)
  • fix: fix(gitops-engine): trim excess capacity from cached compressed manifests (#30779) (#30780)
  • fix: fix(health): handle Crossplane Providers missing the Installed or Healthy condition (#23363) (#30429)
  • …and 166 more

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 1 removed · edges 0 added · 1 removed

Removed bounded contexts (1)

  • github.com/argoproj/argo-cd/gitops-engine/v3

Removed dependency edges (was a dependency, now gone) (1)

  • github.com/argoproj/argo-cd/v3 → github.com/argoproj/argo-cd/gitops-engine/v3

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

argoproj/argo-cd was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit b4af7e752e6a548c3b506ba63917dbf8196e3596 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.