refactor!: remove ResolvedOpenLineageAppName struct

Author: razvan

rust/operator-binary/src/crd/mod.rs

@@ -800,7 +800,7 @@ impl v1alpha1::SparkApplication {
             // Stable job name — fixes the intermittent `unknown` bug (see the usage guide).
             submit_conf.insert(
                 "spark.openlineage.appName".to_string(),
-                self.resolved_openlineage_app_name()?.name,
+                self.resolved_openlineage_app_name()?,
             );
         }
 
@@ -1898,8 +1898,7 @@ spec:
               sparkConf:
                 spark.app.name: spark-conf-name
         "#},
-        "explicit-name",
-        false
+        "explicit-name"
     )]
     #[case::spark_app_name(
         indoc! {r#"
@@ -1922,8 +1921,7 @@ spec:
               sparkConf:
                 spark.app.name: spark-conf-name
         "#},
-        "spark-conf-name",
-        false
+        "spark-conf-name"
     )]
     #[case::metadata_name_fallback(
         indoc! {r#"
@@ -1944,21 +1942,15 @@ spec:
                     host: marquez
                     port: 5000
         "#},
-        "metadata-name",
-        true
+        "metadata-name"
     )]
-    fn test_openlineage_app_name_resolution(
-        #[case] yaml: &str,
-        #[case] expected_name: &str,
-        #[case] expected_from_metadata_name: bool,
-    ) {
+    fn test_openlineage_app_name_resolution(#[case] yaml: &str, #[case] expected_name: &str) {
         let deserializer = serde_yaml::Deserializer::from_str(yaml);
         let spark_application: v1alpha1::SparkApplication =
             serde_yaml::with::singleton_map_recursive::deserialize(deserializer).unwrap();
         let resolved = spark_application.resolved_openlineage_app_name().unwrap();
 
-        assert_eq!(resolved.name, expected_name);
-        assert_eq!(resolved.from_metadata_name, expected_from_metadata_name);
+        assert_eq!(resolved, expected_name);
     }
 
     impl RoundtripTestData for v1alpha1::SparkApplicationSpec {

rust/operator-binary/src/openlineage.rs

@@ -13,18 +13,6 @@ use snafu::OptionExt;
 
 use crate::crd::{Error, ObjectHasNoNameSnafu, v1alpha1};
 
-/// The resolved OpenLineage job/app name and where it came from.
-/// See [`v1alpha1::SparkApplication::resolved_openlineage_app_name`].
-#[derive(Clone, Debug, PartialEq)]
-pub struct ResolvedOpenLineageAppName {
-    /// The resolved, non-blank name written to `spark.openlineage.appName`.
-    pub name: String,
-    /// `true` when the name fell back to `metadata.name`; the controller then emits a warning event
-    /// because a per-run-unique name (e.g. an orchestrator-generated `-<timestamp>` suffix) fragments
-    /// backend run history.
-    pub from_metadata_name: bool,
-}
-
 /// Appends `value` to a comma-separated `--conf` value in `submit_conf`, preserving any existing
 /// (e.g. user-supplied) entries and skipping `value` if it is already present. Used for the
 /// OpenLineage keys that must accumulate rather than clobber (`spark.extraListeners`, `spark.jars`).
@@ -43,36 +31,26 @@ pub(crate) fn append_conf_csv(submit_conf: &mut BTreeMap<String, String>, key: &
 }
 
 impl v1alpha1::SparkApplication {
-    /// Resolves the stable OpenLineage job/app name and its provenance (MVP §5), in priority order:
+    /// Resolves the stable OpenLineage job/app name (MVP §5), in priority order:
     /// 1. `spec.openLineage.appName`, else
     /// 2. `spark.app.name` from `sparkConf`, else
-    /// 3. `metadata.name` (a fallback the controller flags with a warning event, because a
-    ///    per-run-unique name would fragment backend run history).
+    /// 3. `metadata.name`.
     ///
     /// Always yields a non-blank name — which is exactly what fixes the intermittent `unknown` bug.
-    pub fn resolved_openlineage_app_name(&self) -> Result<ResolvedOpenLineageAppName, Error> {
+    pub fn resolved_openlineage_app_name(&self) -> Result<String, Error> {
         if let Some(app_name) = self
             .spec
             .open_lineage
             .as_ref()
             .and_then(|open_lineage| open_lineage.app_name.clone())
         {
-            return Ok(ResolvedOpenLineageAppName {
-                name: app_name,
-                from_metadata_name: false,
-            });
+            return Ok(app_name);
         }
 
         if let Some(app_name) = self.spec.spark_conf.get("spark.app.name") {
-            return Ok(ResolvedOpenLineageAppName {
-                name: app_name.clone(),
-                from_metadata_name: false,
-            });
+            return Ok(app_name.clone());
         }
 
-        Ok(ResolvedOpenLineageAppName {
-            name: self.metadata.name.clone().context(ObjectHasNoNameSnafu)?,
-            from_metadata_name: true,
-        })
+        self.metadata.name.clone().context(ObjectHasNoNameSnafu)
     }
 }

rust/operator-binary/src/spark_k8s_controller.rs

@@ -4,12 +4,9 @@ use snafu::{ResultExt, Snafu};
 use stackable_operator::{
     builder::{self},
     kube::{
-        Resource, ResourceExt,
+        ResourceExt,
         core::{DeserializeGuard, error_boundary},
-        runtime::{
-            controller::Action,
-            events::{Event, EventType, Recorder},
-        },
+        runtime::controller::Action,
     },
     logging::controller::ReconcilerError,
     shared::time::Duration,
@@ -227,17 +224,6 @@ pub async fn reconcile(
         .await
         .context(ApplyApplicationSnafu)?;
 
-    // Warn if the OpenLineage job name falls back to `metadata.name` — only matters when
-    // OpenLineage is enabled.
-    if spark_application.spec.open_lineage.is_some()
-        && spark_application
-            .resolved_openlineage_app_name()
-            .context(BuildCommandSnafu)?
-            .from_metadata_name
-    {
-        publish_openlineage_app_name_warning(&ctx.event_recorder, spark_application).await;
-    }
-
     let job_commands = spark_application
         .build_command(
             opt_s3conn,
@@ -312,38 +298,3 @@ pub fn error_policy(
         _ => Action::requeue(*Duration::from_secs(5)),
     }
 }
-
-/// Emits a Kubernetes warning event that the OpenLineage job name fell back to `metadata.name`,
-/// which fragments backend run history when that name is unique per run. Event-publishing failures
-/// are logged, not propagated — they must not fail reconciliation.
-async fn publish_openlineage_app_name_warning(
-    event_recorder: &Recorder,
-    spark_application: &v1alpha1::SparkApplication,
-) {
-    let name = spark_application.name_any();
-    let publish_result = event_recorder
-        .publish(
-            &Event {
-                type_: EventType::Warning,
-                reason: "OpenLineageAppNameFallback".into(),
-                note: Some(format!(
-                    "OpenLineage job name falls back to metadata.name ({name:?}) because neither \
-                     spec.openLineage.appName nor spark.app.name is set. If metadata.name is unique \
-                     per run (e.g. an orchestrator-generated -<timestamp> suffix), backend run \
-                     history will be fragmented into a new job per run. Set \
-                     spec.openLineage.appName to a stable value to avoid this."
-                )),
-                action: "ResolveOpenLineageAppName".into(),
-                secondary: None,
-            },
-            &spark_application.object_ref(&()),
-        )
-        .await;
-
-    if let Err(error) = publish_result {
-        tracing::warn!(
-            ?error,
-            "failed to publish OpenLineage app-name fallback warning event"
-        );
-    }
-}