fix(ohno): address some correctness and usability findings

Correctness:
- Fix compounding name bug in generate_unique_field_name (ohno_core_1_2 instead of ohno_core_2 on repeated collision)
- Emit clear compile error when #[ohno::error] is applied to enums
- Add #[track_caller] to Option<T> IntoAppError implementations

Usability:
- Make enrichments()/enrichment_messages() iterate in chronological order (oldest-first), consistent with format_error display order

Author: Martin Taillefer

crates/automation/src/lib.rs

@@ -52,7 +52,7 @@ pub fn list_packages(workspace_root: impl AsRef<Path>) -> Result<Vec<PackageMeta
 
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
-        ohno::bail!("cargo metadata failed: {stderr}");
+        ohno::bail!("cargo metadata failed: {}", stderr);
     }
 
     let metadata: CargoMetadata = serde_json::from_slice(&output.stdout).into_app_err("failed to parse cargo metadata output")?;

crates/ohno/src/app/into_app_err.rs

@@ -70,10 +70,12 @@ where
 }
 
 impl<T> IntoAppError<T> for Option<T> {
+    #[track_caller]
     fn into_app_err(self, msg: impl Display) -> Result<T, AppError> {
         self.ok_or_else(|| AppError::new(msg.to_string()))
     }
 
+    #[track_caller]
     fn into_app_err_with<F, D>(self, msg_fn: F) -> Result<T, AppError>
     where
         F: FnOnce() -> D,

crates/ohno/src/core.rs

@@ -103,14 +103,14 @@ impl OhnoCore {
         self.data.backtrace.as_backtrace()
     }
 
-    /// Returns an iterator over the enrichment information in reverse order (most recent first).
+    /// Returns an iterator over the enrichment information in chronological order (oldest first).
     pub fn enrichments(&self) -> impl Iterator<Item = &EnrichmentEntry> {
-        self.data.enrichment.iter().rev()
+        self.data.enrichment.iter()
     }
 
-    /// Returns an iterator over just the enrichment messages in reverse order (most recent first).
+    /// Returns an iterator over just the enrichment messages in chronological order (oldest first).
     pub fn enrichment_messages(&self) -> impl Iterator<Item = &str> {
-        self.data.enrichment.iter().rev().map(|ctx| ctx.message.as_ref())
+        self.data.enrichment.iter().map(|ctx| ctx.message.as_ref())
     }
 
     /// Formats the main error message without backtrace and error enrichment.
@@ -305,7 +305,7 @@ mod tests {
         error.add_enrichment(EnrichmentEntry::new("ctx1", "test.rs", 1));
         error.add_enrichment(EnrichmentEntry::new("ctx2", "test.rs", 2));
         let messages: Vec<_> = error.enrichment_messages().collect();
-        assert_eq!(messages, vec!["ctx2", "ctx1"]);
+        assert_eq!(messages, vec!["ctx1", "ctx2"]);
     }
 
     #[test]

crates/ohno/tests/core.rs

@@ -75,10 +75,10 @@ fn test_detailed_enrich() {
     let enrichments: Vec<_> = error.enrichments().collect();
     assert_eq!(enrichments.len(), 3);
 
-    // Most recent first
-    assert_eq!(enrichments[0].message, "third message");
+    // Oldest first (chronological), matching display order
+    assert_eq!(enrichments[0].message, "first message");
     assert_eq!(enrichments[1].message, "second message");
-    assert_eq!(enrichments[2].message, "first message");
+    assert_eq!(enrichments[2].message, "third message");
 }
 
 #[test]
@@ -125,7 +125,7 @@ fn test_trace_messages_iterator() {
     let error = OhnoCore::from("base").enrich("first").enrich("second");
 
     let messages: Vec<_> = error.enrichment_messages().collect();
-    assert_eq!(messages, vec!["second", "first"]);
+    assert_eq!(messages, vec!["first", "second"]);
 
     let display = error.to_string();
     let lines: Vec<_> = display.lines().collect();

crates/ohno/tests/enrich_err.rs

@@ -330,7 +330,7 @@ fn empty_context_iter() {
 }
 
 #[test]
-fn context_iter_reverse_order() {
+fn context_iter_chronological_order() {
     let mut core = OhnoCore::default();
 
     let messages = ["msg 1", "msg 2", "msg 3", "msg 4", "msg 5"];
@@ -351,11 +351,11 @@ fn context_iter_reverse_order() {
     assert_eq!(
         messages,
         vec![
-            ("msg 5", "test.rs", 50),
-            ("msg 4", "test.rs", 40),
-            ("msg 3", "test.rs", 30),
-            ("msg 2", "test.rs", 20),
             ("msg 1", "test.rs", 10),
+            ("msg 2", "test.rs", 20),
+            ("msg 3", "test.rs", 30),
+            ("msg 4", "test.rs", 40),
+            ("msg 5", "test.rs", 50),
         ]
     );
 }

crates/ohno_macros/src/error_type_attr.rs

@@ -45,11 +45,16 @@ use crate::utils::generate_unique_field_name;
 #[cfg_attr(test, mutants::skip)] // procedural macro API cannot be used in tests directly
 pub fn error(_args: TokenStream, input: TokenStream) -> TokenStream {
     let mut input = parse_macro_input!(input as DeriveInput);
+    TokenStream::from(error_impl(&mut input))
+}
 
-    add_fiasko_error_derive(&mut input);
-    add_ohno_core_field(&mut input);
+fn error_impl(input: &mut DeriveInput) -> proc_macro2::TokenStream {
+    if let Err(err) = add_ohno_core_field(input) {
+        return err.to_compile_error();
+    }
+    add_fiasko_error_derive(input);
 
-    TokenStream::from(quote! { #input })
+    quote! { #input }
 }
 
 fn add_fiasko_error_derive(input: &mut DeriveInput) {
@@ -61,7 +66,7 @@ fn add_fiasko_error_derive(input: &mut DeriveInput) {
     );
 }
 
-fn add_ohno_core_field(input: &mut DeriveInput) {
+fn add_ohno_core_field(input: &mut DeriveInput) -> syn::Result<()> {
     if let Data::Struct(data_struct) = &mut input.data {
         match &mut data_struct.fields {
             Fields::Unit => {
@@ -95,8 +100,12 @@ fn add_ohno_core_field(input: &mut DeriveInput) {
                 });
             }
         }
+        Ok(())
     } else {
-        // Not a struct, can't transform
+        Err(syn::Error::new_spanned(
+            &input.ident,
+            "#[ohno::error] can only be applied to structs",
+        ))
     }
 }
 
@@ -134,7 +143,7 @@ mod tests {
             }
         };
 
-        crate::error_type_attr::add_ohno_core_field(&mut input);
+        crate::error_type_attr::add_ohno_core_field(&mut input).unwrap();
 
         let expected: proc_macro2::TokenStream = parse_quote! {
             struct TestError {
@@ -149,19 +158,52 @@ mod tests {
 
     #[test]
     fn test_add_ohno_core_field_with_enum() {
-        // Test that the function doesn't crash when given an enum
-        // This covers line 99 (the else branch for non-struct types)
+        // Test that the function returns an error when given an enum
         let mut input: DeriveInput = parse_quote! {
             enum TestError {
                 Variant1,
                 Variant2,
             }
         };
 
-        let original = input.to_token_stream().to_string();
-        crate::error_type_attr::add_ohno_core_field(&mut input);
+        let result = crate::error_type_attr::add_ohno_core_field(&mut input);
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(err.to_string().contains("#[ohno::error] can only be applied to structs"));
+    }
+
+    #[test]
+    fn test_add_ohno_core_field_enum_produces_compile_error() {
+        // Verifies the to_compile_error() path used by the error proc macro (line 50)
+        let mut input: DeriveInput = parse_quote! {
+            enum NotAStruct {
+                A,
+            }
+        };
+
+        let err = crate::error_type_attr::add_ohno_core_field(&mut input).unwrap_err();
+        let compile_error = err.to_compile_error().to_string();
+
+        assert!(compile_error.contains("compile_error"));
+        assert!(
+            compile_error.contains("#[ohno::error] can only be applied to structs"),
+            "compile error should contain the expected message, got: {compile_error}"
+        );
+    }
+
+    #[test]
+    fn test_error_impl_returns_compile_error_for_enum() {
+        let mut input: DeriveInput = parse_quote! {
+            enum NotAStruct {
+                A,
+            }
+        };
+
+        let output = crate::error_type_attr::error_impl(&mut input).to_string();
 
-        // The enum should remain unchanged since we can't transform it
-        assert_eq!(input.to_token_stream().to_string(), original);
+        assert!(
+            output.contains("compile_error"),
+            "error_impl should return a compile_error token stream for enums, got: {output}"
+        );
     }
 }

crates/ohno_macros/src/utils.rs

@@ -48,7 +48,7 @@ pub fn generate_unique_field_name(existing_fields: &[&syn::Ident]) -> syn::Ident
     let mut counter = 0;
     while existing_fields.iter().any(|ident| ident == &AsRef::<str>::as_ref(&candidate)) {
         counter += 1;
-        candidate = format!("{candidate}_{counter}");
+        candidate = format!("ohno_core_{counter}");
     }
 
     syn::Ident::new(&candidate, proc_macro2::Span::call_site())
@@ -110,4 +110,17 @@ mod tests {
         // Verify that the returned name is NOT in the existing fields
         assert!(!fields.iter().any(|ident| name == ident.to_string()));
     }
+
+    #[test]
+    fn test_generate_unique_field_name_multiple_collisions() {
+        let ident1 = syn::Ident::new("ohno_core", proc_macro2::Span::call_site());
+        let ident2 = syn::Ident::new("ohno_core_1", proc_macro2::Span::call_site());
+        let ident3 = syn::Ident::new("ohno_core_2", proc_macro2::Span::call_site());
+        let fields = vec![&ident1, &ident2, &ident3];
+
+        let name = generate_unique_field_name(&fields);
+
+        // Should return "ohno_core_3", not a compounding name like "ohno_core_1_2_3"
+        assert_eq!(name.to_string(), "ohno_core_3");
+    }
 }

crates/seatbelt/Cargo.toml

@@ -73,27 +73,27 @@ tracing-subscriber = { workspace = true, features = ["fmt", "std"] }
 
 [[example]]
 name = "timeout"
-required-features = ["timeout"]
+required-features = ["timeout", "metrics"]
 
 [[example]]
 name = "timeout_advanced"
-required-features = ["timeout"]
+required-features = ["timeout", "metrics"]
 
 [[example]]
 name = "retry"
 required-features = ["retry"]
 
 [[example]]
 name = "retry_advanced"
-required-features = ["retry"]
+required-features = ["retry", "metrics"]
 
 [[example]]
 name = "retry_outage"
-required-features = ["retry"]
+required-features = ["retry", "metrics"]
 
 [[example]]
 name = "resilience_pipeline"
-required-features = ["retry", "timeout"]
+required-features = ["retry", "timeout", "metrics"]
 
 [[example]]
 name = "tower"

crates/seatbelt/src/context.rs

@@ -73,7 +73,12 @@ impl<In, Out> ResilienceContext<In, Out> {
 
     #[cfg_attr(
         not(any(feature = "metrics", feature = "logs", test)),
-        expect(unused_variables, reason = "unused when logs nor metrics are used")
+        expect(
+            unused_variables,
+            clippy::unused_self,
+            clippy::needless_pass_by_value,
+            reason = "unused when logs nor metrics are used"
+        )
     )]
     #[cfg(any(feature = "retry", feature = "breaker", feature = "timeout", test))]
     pub(crate) fn create_telemetry(&self, strategy_name: Cow<'static, str>) -> crate::utils::TelemetryHelper {

crates/seatbelt/src/retry/service.rs

@@ -217,7 +217,7 @@ impl<In, Out> RetryShared<In, Out> {
 
     #[cfg_attr(
         not(any(feature = "logs", test)),
-        expect(unused_variables, reason = "unused when logs feature not used")
+        expect(unused_variables, clippy::unused_self, reason = "unused when logs feature not used")
     )]
     fn emit_telemetry(&self, attempt: Attempt, retry_delay: Duration) {
         #[cfg(any(feature = "logs", test))]