argoproj/argo-cd
58.4
Adequate · 13 November 2026
112k
lines of production code
Go
with JavaScript, Lua
6
measurements over time
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.