fix: don't hard-crash on owner lookup failure

Author: drmorr0

.rustfmt.toml

@@ -1,4 +1,4 @@
-edition = "2021"
+edition = "2024"
 array_width = 100
 blank_lines_upper_bound = 2
 chain_width = 80

sk-store/src/manager.rs

@@ -1,6 +1,7 @@
 use std::sync::Arc;
 
 use sk_core::k8s::DynamicApiSet;
+use sk_core::prelude::*;
 use tokio::sync::{
     Mutex,
     mpsc,
@@ -77,13 +78,23 @@ pub(crate) async fn handle_messages(
                     TraceAction::ObjectDeleted => store.delete_obj(&request.obj, request.ts),
                 };
                 if let Err(err) = res {
-                    error!("could not send dynamic object update for {request:?}: {err}");
+                    error!(
+                        "could not send dynamic object update for ({:?}, {}, {}): {err}",
+                        request.action,
+                        request.obj.namespaced_name(),
+                        request.ts,
+                    );
                 }
             },
             Some(request) = pod_rx.recv() => {
                 let mut store = m_store.lock().await;
-                if let Err(err) = store.record_pod_lifecycle(&request.ns_name, &request.maybe_pod, &request.lifecycle_data).await {
-                    error!("could not send dynamic object update for {request:?}: {err}");
+                if let Err(err) = store.record_pod_lifecycle(
+                    &request.ns_name,
+                    &request.maybe_pod,
+                    &request.lifecycle_data,
+                ).await {
+                    error!("could not send pod object update for ({}, {:?}, {:?}): {err}",
+                        request.ns_name, request.maybe_pod.map(|p| p.namespaced_name()), request.lifecycle_data);
                 }
             },
             else => break,

sk-store/src/store.rs

@@ -208,15 +208,14 @@ impl TraceStore {
         // because those _can_ change).
         if self.pod_owners.has_pod(ns_name) {
             self.pod_owners.update_pod_lifecycle(ns_name, lifecycle_data)?;
-        } else if let Some(pod) = maybe_pod {
-            // Otherwise, we need to check if any of the pod's owners are tracked by us
-            let gvk = corev1::Pod::gvk();
-            let owners = self
+        } else if let Some(pod) = maybe_pod
+            && let Ok(owners) = self
                 .owners_cache
                 .lock()
                 .await
-                .lookup_by_name_or_obj(&gvk, ns_name, maybe_pod.as_ref())
-                .await?;
+                .lookup_by_name_or_obj(&corev1::Pod::gvk(), ns_name, maybe_pod.as_ref())
+                .await
+        {
             for owner in owners {
                 // Pods are guaranteed to have namespaces, so the unwrap is fine
                 let owner_ns_name = format!("{}/{}", pod.namespace().unwrap(), owner.name);
@@ -268,7 +267,12 @@ impl TraceStore {
             .lock()
             .await
             .lookup_by_name_or_obj(gvk, ns_name, Some(obj))
-            .await?;
+            .await
+            .unwrap_or_else(|err| {
+                error!("could not determine owners for {}, disregarding: {err}", format_gvk_name(gvk, ns_name));
+                vec![]
+            });
+
         for owner in owners {
             // TODO right now we only look up _namespaced_ owners, not cluster-scoped; in
             // principle, it's possible to get the cluster-scoped owners, since the owner